From d177023e44cbc500d9d3a900e3154ae8d8c0df22 Mon Sep 17 00:00:00 2001
From: "Adam D. Ruppe" <destructionator@gmail.com>
Date: Wed, 10 Nov 2021 09:47:03 -0500
Subject: [PATCH] more work in progress

---
 minigui_addons/webview.d |   526 +
 webview.d                | 28920 +++++++++++++++++++------------------
 2 files changed, 15262 insertions(+), 14184 deletions(-)
 create mode 100644 minigui_addons/webview.d

diff --git a/minigui_addons/webview.d b/minigui_addons/webview.d
new file mode 100644
index 0000000..26d706a
--- /dev/null
+++ b/minigui_addons/webview.d
@@ -0,0 +1,526 @@
+/++
+	A webview (based on [arsd.webview]) for minigui.
+
+	For now at least, to use this, you MUST have a CefApp in scope in main for the duration of your gui application.
+
+	History:
+		Added November 5, 2021. NOT YET STABLE.
++/
+module minigui_addons.webview;
+
+version(linux)
+	version=cef;
+version(Windows)
+	version=wv2;
+
+
+class StateChanged(alias field) : Event {
+	enum EventString = __traits(identifier, __traits(parent, field)) ~ "." ~ __traits(identifier, field) ~ ":change";
+	override bool cancelable() const { return false; }
+	this(Widget target, typeof(field) newValue) {
+		this.newValue = newValue;
+		super(EventString, target);
+	}
+
+	typeof(field) newValue;
+}
+
+void addWhenTriggered(Widget w, void delegate() dg) {
+	w.addEventListener("triggered", dg);
+}
+
+mixin template Observable(T, string name) {
+	private T backing;
+
+	mixin(q{
+		void } ~ name ~ q{_changed (void delegate(T) dg) {
+			this.addEventListener((StateChanged!this_thing ev) {
+				dg(ev.newValue);
+			});
+		}
+
+		@property T } ~ name ~ q{ () {
+			return backing;
+		}
+
+		@property void } ~ name ~ q{ (T t) {
+			backing = t;
+			auto event = new StateChanged!this_thing(this, t);
+			event.dispatch();
+		}
+	});
+
+	mixin("private alias this_thing = " ~ name ~ ";");
+}
+
+/+
+	SPA mode: put favicon on top level window, no other user controls at top level, links to different domains always open in new window.
++/
+
+// FIXME: look in /opt/cef for the dll and the locales
+
+import arsd.minigui;
+import arsd.webview;
+
+version(wv2)
+	alias WebViewWidget = WebViewWidget_WV2;
+else version(cef)
+	alias WebViewWidget = WebViewWidget_CEF;
+else static assert(0, "no webview available");
+
+class WebViewWidgetBase : NestedChildWindowWidget {
+	protected SimpleWindow containerWindow;
+
+	protected this(Widget parent) {
+		containerWindow = new SimpleWindow(640, 480, null, OpenGlOptions.no, Resizability.allowResizing, WindowTypes.nestedChild, WindowFlags.normal, getParentWindow(parent));
+
+		super(containerWindow, parent);
+	}
+
+	mixin Observable!(string, "title");
+	mixin Observable!(string, "url");
+	mixin Observable!(string, "status");
+	mixin Observable!(int, "loadingProgress");
+
+	abstract void refresh();
+	abstract void back();
+	abstract void forward();
+	abstract void stop();
+
+	abstract void navigate(string url);
+
+	// the url and line are for error reporting purposes
+	abstract void executeJavascript(string code, string url = null, int line = 0);
+
+	abstract void showDevTools();
+
+	// this is implemented as a do-nothing in the NestedChildWindowWidget base
+	// but you will almost certainly need to override it in implementations.
+	// abstract void registerMovementAdditionalWork();
+}
+
+
+version(wv2)
+class WebViewWidget_WV2 : WebViewWidgetBase {
+	private RC!ICoreWebView2 webview_window;
+	private RC!ICoreWebView2Environment webview_env;
+	private RC!ICoreWebView2Controller controller;
+
+	private bool initialized;
+
+	this(Widget parent) {
+		super(parent);
+		// that ctor sets containerWindow
+
+		Wv2App.useEnvironment((env) {
+			env.CreateCoreWebView2Controller(containerWindow.impl.hwnd,
+				callback!(ICoreWebView2CreateCoreWebView2ControllerCompletedHandler)(delegate(error, controller_raw) {
+					if(error || controller_raw is null)
+						return error;
+
+					// need to keep this beyond the callback or we're doomed.
+					controller = RC!ICoreWebView2Controller(controller_raw);
+
+					webview_window = controller.CoreWebView2;
+
+					RC!ICoreWebView2Settings Settings = webview_window.Settings;
+					Settings.IsScriptEnabled = TRUE;
+					Settings.AreDefaultScriptDialogsEnabled = TRUE;
+					Settings.IsWebMessageEnabled = TRUE;
+
+
+					auto ert = webview_window.add_NavigationStarting(
+						delegate (sender, args) {
+							wchar* t;
+							args.get_Uri(&t);
+							auto ot = t;
+
+							string s;
+
+							while(*t) {
+								s ~= *t;
+								t++;
+							}
+
+							this.url = s;
+
+							CoTaskMemFree(ot);
+
+							return S_OK;
+						});
+
+					RECT bounds;
+					GetClientRect(containerWindow.impl.hwnd, &bounds);
+					controller.Bounds = bounds;
+					error = webview_window.Navigate("http://arsdnet.net/test.html"w.ptr);
+					//error = webview_window.NavigateToString("<html><body>Hello</body></html>"w.ptr);
+					//error = webview_window.Navigate("http://192.168.1.10/"w.ptr);
+
+					controller.IsVisible = true;
+
+					initialized = true;
+
+					return S_OK;
+				}));
+			});
+	}
+
+	override void registerMovementAdditionalWork() {
+		if(initialized) {
+			RECT bounds;
+			GetClientRect(containerWindow.impl.hwnd, &bounds);
+			controller.Bounds = bounds;
+
+			controller.NotifyParentWindowPositionChanged();
+		}
+	}
+
+	override void refresh() {
+		if(!initialized) return;
+		webview_window.Reload();
+	}
+	override void back() {
+		if(!initialized) return;
+		webview_window.GoBack();
+	}
+	override void forward() {
+		if(!initialized) return;
+		webview_window.GoForward();
+	}
+	override void stop() {
+		if(!initialized) return;
+		webview_window.Stop();
+	}
+
+	override void navigate(string url) {
+		if(!initialized) return;
+		import std.utf;
+		auto error = webview_window.Navigate(url.toUTF16z);
+	}
+
+	// the url and line are for error reporting purposes
+	override void executeJavascript(string code, string url = null, int line = 0) {
+		if(!initialized) return;
+		import std.utf;
+		webview_window.ExecuteScript(code.toUTF16z, null);
+	}
+
+	override void showDevTools() {
+		if(!initialized) return;
+		webview_window.OpenDevToolsWindow();
+	}
+}
+
+version(cef)
+class WebViewWidget_CEF : WebViewWidgetBase {
+	this(Widget parent) {
+		//semaphore = new Semaphore;
+		assert(CefApp.active);
+
+		super(parent);
+
+		flushGui();
+
+		mapping[containerWindow.nativeWindowHandle()] = this;
+
+		cef_window_info_t window_info;
+		window_info.parent_window = containerWindow.nativeWindowHandle;
+
+		cef_string_t cef_url = cef_string_t("http://arsdnet.net/test.html");
+
+		cef_browser_settings_t browser_settings;
+		browser_settings.size = cef_browser_settings_t.sizeof;
+
+		client = new MiniguiCefClient();
+
+		auto got = libcef.browser_host_create_browser(&window_info, client.passable, &cef_url, &browser_settings, null, null);
+
+		/+
+		containerWindow.closeQuery = delegate() {
+			browserHandle.get_host.close_browser(true);
+			//containerWindow.close();
+		};
+		+/
+
+	}
+
+	private MiniguiCefClient client;
+
+	/+
+	override void close() {
+		// FIXME: this should prolly be on the onclose event instead
+		mapping.remove[win.nativeWindowHandle()];
+		super.close();
+	}
+	+/
+
+	override void registerMovementAdditionalWork() {
+		if(browserWindow) {
+			static if(UsingSimpledisplayX11)
+				XResizeWindow(XDisplayConnection.get, browserWindow, width, height);
+			// FIXME: do for Windows too
+		}
+	}
+
+
+	private NativeWindowHandle browserWindow;
+	private RC!cef_browser_t browserHandle;
+
+	private static WebViewWidget[NativeWindowHandle] mapping;
+	private static WebViewWidget[NativeWindowHandle] browserMapping;
+
+	override void refresh() { if(browserHandle) browserHandle.reload(); }
+	override void back() { if(browserHandle) browserHandle.go_back(); }
+	override void forward() { if(browserHandle) browserHandle.go_forward(); }
+	override void stop() { if(browserHandle) browserHandle.stop_load(); }
+
+	override void navigate(string url) {
+		if(!browserHandle) return;
+		auto s = cef_string_t(url);
+		browserHandle.get_main_frame.load_url(&s);
+	}
+
+	// the url and line are for error reporting purposes
+	override void executeJavascript(string code, string url = null, int line = 0) {
+		if(!browserHandle) return;
+
+		auto c = cef_string_t(code);
+		auto u = cef_string_t(url);
+		browserHandle.get_main_frame.execute_java_script(&c, &u, line);
+	}
+
+	override void showDevTools() {
+		if(!browserHandle) return;
+		browserHandle.get_host.show_dev_tools(null /* window info */, client.passable, null /* settings */, null /* inspect element at coordinates */);
+	}
+
+	// FYI the cef browser host also allows things like custom spelling dictionaries and getting navigation entries.
+
+	// JS on init?
+	// JS bindings?
+	// user styles?
+	// navigate to string? (can just use a data uri maybe?)
+	// custom scheme handlers?
+
+	// navigation callbacks to prohibit certain things or move links to new window etc?
+}
+
+version(cef) {
+
+	//import core.sync.semaphore;
+	//__gshared Semaphore semaphore;
+
+	/+
+		Finds the WebViewWidget associated with the given browser, then runs the given code in the gui thread on it.
+	+/
+	void runOnWebView(RC!cef_browser_t browser, void delegate(WebViewWidget) dg) nothrow {
+		auto wh = cast(NativeWindowHandle) browser.get_host.get_window_handle;
+		runInGuiThreadAsync({
+			if(auto wvp = wh in WebViewWidget.browserMapping) {
+				dg(*wvp);
+			} else {
+				//writeln("not found ", wh, WebViewWidget.browserMapping);
+			}
+		});
+	}
+
+	class MiniguiCefLifeSpanHandler : CEF!cef_life_span_handler_t {
+		override int on_before_popup(RC!cef_browser_t, RC!cef_frame_t, const(cef_string_utf16_t)*, const(cef_string_utf16_t)*, cef_window_open_disposition_t, int, const(cef_popup_features_t)*, cef_window_info_t*, cef_client_t**, cef_browser_settings_t*, cef_dictionary_value_t**, int*) {
+			return 0;
+		}
+		override void on_after_created(RC!cef_browser_t browser) {
+			auto handle = cast(NativeWindowHandle) browser.get_host().get_window_handle();
+			auto ptr = browser.passable; // this adds to the refcount until it gets inside
+
+			// the only reliable key (at least as far as i can tell) is the window handle
+			// so gonna look that up and do the sync mapping that way.
+			runInGuiThreadAsync({
+				version(Windows) {
+					auto parent = GetParent(handle);
+				} else static if(UsingSimpledisplayX11) {
+					import arsd.simpledisplay : Window;
+					Window root;
+					Window parent;
+					uint c = 0;
+					auto display = XDisplayConnection.get;
+					Window* children;
+					XQueryTree(display, handle, &root, &parent, &children, &c);
+					XFree(children);
+				} else static assert(0);
+
+				if(auto wvp = parent in WebViewWidget.mapping) {
+					auto wv = *wvp;
+					wv.browserWindow = handle;
+					wv.browserHandle = RC!cef_browser_t(ptr);
+
+					wv.registerMovementAdditionalWork();
+
+					WebViewWidget.browserMapping[handle] = wv;
+				} else assert(0);
+			});
+		}
+		override int do_close(RC!cef_browser_t browser) {
+			return 0;
+		}
+		override void on_before_close(RC!cef_browser_t browser) {
+			/+
+			import std.stdio; debug writeln("notify");
+			try
+			semaphore.notify;
+			catch(Exception e) { assert(0); }
+			+/
+		}
+	}
+
+	class MiniguiLoadHandler : CEF!cef_load_handler_t {
+		override void on_loading_state_change(RC!(cef_browser_t) browser, int isLoading, int canGoBack, int canGoForward) {
+			/+
+			browser.runOnWebView((WebViewWidget wvw) {
+				wvw.parentWindow.win.title = wvw.browserHandle.get_main_frame.get_url.toGCAndFree;
+			});
+			+/
+		}
+		override void on_load_start(RC!(cef_browser_t), RC!(cef_frame_t), cef_transition_type_t) {
+		}
+		override void on_load_error(RC!(cef_browser_t), RC!(cef_frame_t), cef_errorcode_t, const(cef_string_utf16_t)*, const(cef_string_utf16_t)*) {
+		}
+		override void on_load_end(RC!(cef_browser_t), RC!(cef_frame_t), int) {
+		}
+	}
+
+	class MiniguiDialogHandler : CEF!cef_dialog_handler_t {
+
+		override int on_file_dialog(RC!(cef_browser_t) browser, cef_file_dialog_mode_t mode, const(cef_string_utf16_t)* title, const(cef_string_utf16_t)* default_file_path, cef_string_list_t accept_filters, int selected_accept_filter, RC!(cef_file_dialog_callback_t) callback) {
+			try {
+				auto ptr = callback.passable();
+				runInGuiThreadAsync({
+					getOpenFileName((string name) {
+						auto callback = RC!cef_file_dialog_callback_t(ptr);
+						auto list = libcef.string_list_alloc();
+						auto item = cef_string_t(name);
+						libcef.string_list_append(list, &item);
+						callback.cont(selected_accept_filter, list);
+					}, null, null, () {
+						auto callback = RC!cef_file_dialog_callback_t(ptr);
+						callback.cancel();
+					});
+				});
+			} catch(Exception e) {}
+
+			return 1;
+		}
+	}
+
+	class MiniguiDisplayHandler : CEF!cef_display_handler_t {
+		override void on_address_change(RC!(cef_browser_t) browser, RC!(cef_frame_t), const(cef_string_utf16_t)* address) {
+			auto url = address.toGC;
+			browser.runOnWebView((wv) {
+				wv.url = url;
+			});
+		}
+		override void on_title_change(RC!(cef_browser_t) browser, const(cef_string_utf16_t)* title) {
+			auto t = title.toGC;
+			browser.runOnWebView((wv) {
+				wv.title = t;
+			});
+		}
+		override void on_favicon_urlchange(RC!(cef_browser_t) browser, cef_string_list_t) {
+		}
+		override void on_fullscreen_mode_change(RC!(cef_browser_t) browser, int) {
+		}
+		override int on_tooltip(RC!(cef_browser_t) browser, cef_string_utf16_t*) {
+			return 0;
+		}
+		override void on_status_message(RC!(cef_browser_t) browser, const(cef_string_utf16_t)* msg) {
+			auto status = msg.toGC;
+			browser.runOnWebView((wv) {
+				wv.status = status;
+			});
+		}
+		override void on_loading_progress_change(RC!(cef_browser_t) browser, double progress) {
+			// progress is from 0.0 to 1.0
+			browser.runOnWebView((wv) {
+				wv.loadingProgress = cast(int) (progress * 100);
+			});
+		}
+		override int on_console_message(RC!(cef_browser_t), cef_log_severity_t, const(cef_string_utf16_t)*, const(cef_string_utf16_t)*, int) {
+			return 0; // 1 means to suppress it being automatically output
+		}
+		override int on_auto_resize(RC!(cef_browser_t), const(cef_size_t)*) {
+			return 0;
+		}
+		override int on_cursor_change(RC!(cef_browser_t), cef_cursor_handle_t, cef_cursor_type_t, const(cef_cursor_info_t)*) {
+			return 0;
+		}
+	}
+
+	class MiniguiCefClient : CEF!cef_client_t {
+		MiniguiCefLifeSpanHandler lsh;
+		MiniguiLoadHandler loadHandler;
+		MiniguiDialogHandler dialogHandler;
+		MiniguiDisplayHandler displayHandler;
+		this() {
+			lsh = new MiniguiCefLifeSpanHandler();
+			loadHandler = new MiniguiLoadHandler();
+			dialogHandler = new MiniguiDialogHandler();
+			displayHandler = new MiniguiDisplayHandler();
+		}
+
+		override cef_audio_handler_t* get_audio_handler() {
+			return null;
+		}
+		override cef_context_menu_handler_t* get_context_menu_handler() {
+			return null;
+		}
+		override cef_dialog_handler_t* get_dialog_handler() {
+			return dialogHandler.returnable;
+		}
+		override cef_display_handler_t* get_display_handler() {
+			return displayHandler.returnable;
+		}
+		override cef_download_handler_t* get_download_handler() {
+			return null;
+		}
+		override cef_drag_handler_t* get_drag_handler() {
+			return null;
+		}
+		override cef_find_handler_t* get_find_handler() {
+			return null;
+		}
+		override cef_focus_handler_t* get_focus_handler() {
+			return null;
+		}
+		override cef_jsdialog_handler_t* get_jsdialog_handler() {
+			// needed for alert etc.
+			return null;
+		}
+		override cef_keyboard_handler_t* get_keyboard_handler() {
+			// this can handle keyboard shortcuts etc
+			return null;
+		}
+		override cef_life_span_handler_t* get_life_span_handler() {
+			return lsh.returnable;
+		}
+		override cef_load_handler_t* get_load_handler() {
+			return loadHandler.returnable;
+		}
+		override cef_render_handler_t* get_render_handler() {
+			// this thing might work for an off-screen thing
+			// like to an image or to a video stream maybe
+			return null;
+		}
+		override cef_request_handler_t* get_request_handler() {
+			return null;
+		}
+		override int on_process_message_received(RC!cef_browser_t, RC!cef_frame_t, cef_process_id_t, RC!cef_process_message_t) {
+			return 0; // return 1 if you can actually handle the message
+		}
+		override cef_frame_handler_t* get_frame_handler() nothrow {
+			return null;
+		}
+		override cef_print_handler_t* get_print_handler() nothrow {
+			return null;
+		}
+
+	}
+}
diff --git a/webview.d b/webview.d
index 60e8136..6047a5d 100644
--- a/webview.d
+++ b/webview.d
@@ -1,111 +1,312 @@
 /++
-	A thin wrapper around common system webviews.
-	Based on: https://github.com/zserge/webview
+	A web view wrapper. Uses CEF on Linux and WebView2 on Windows.
+
+	Microsoft WebView2 is fairly stable and is unlikely to break, but CEF
+	is not remotely stable and likely to break every release. You'll have
+	to get the same version as me to use this unless you want to generate
+	your own bindings (procedure found in the file comments). Details below.
+
+
+	I currently built against 95.7.17+g4208276+chromium-95.0.4638.69 and it
+	uses UTF-16 strings.
+
+	Then to install the cef put in the Resources in the RElease directory and
+	copy the locales to /opt/cef/Resources/Locales
+
+	You can download compatible builds from https://cef-builds.spotifycdn.com/index.html
+	just make sure to put in the version filter and check "all builds" to match it.
+
+	You do NOT actually need the cef to build the application, but it must be
+	on the user's machine to run it. It looks in /opt/cef/ on Linux.
+
+	Work in progress. DO NOT USE YET as I am prolly gonna break everything too.
+
+	On Windows, you need to distribute the WebView2Loader.dll with your exe. That
+	is found in the web view 2 sdk. Furthermore, users will have to install the runtime.
+
+	Please note; the Microsoft terms and conditions say they may be able to collect
+	information about your users if you use this on Windows.
+	see: https://developer.microsoft.com/en-us/microsoft-edge/webview2/
+
 
-	Work in progress. DO NOT USE YET as I am prolly gonna break everything.
 +/
 module arsd.webview;
 
-// FIXME: I think dynamic loading cef might not be that bad; there's only a handful
-// of top level functions. will want to explore.
-
-// Please note; the Microsoft terms and conditions say they may be able to collect
-// information about your users if you use this on Windows.
-// see: https://developer.microsoft.com/en-us/microsoft-edge/webview2/
+// I might recover this gtk thing but i don't like gtk
+// dmdi webview -version=linux_gtk -version=Demo
 
+// the setup link for Microsoft:
 // https://go.microsoft.com/fwlink/p/?LinkId=2124703
 
 
+version(Windows) {
+import arsd.simpledisplay;
+import arsd.com;
+import core.atomic;
+
+//import std.stdio;
+
+T callback(T)(typeof(&T.init.Invoke) dg) {
+	return new class T {
+		extern(Windows):
+
+		static if(is(typeof(T.init.Invoke) R == return))
+		static if(is(typeof(T.init.Invoke) P == __parameters))
+  		override R Invoke(P _args_) {
+			return dg(_args_);
+		}
+
+		override HRESULT QueryInterface(const (IID)*riid, LPVOID *ppv) {
+			if (IID_IUnknown == *riid) {
+				*ppv = cast(void*) cast(IUnknown) this;
+			}
+			else if (T.iid == *riid) {
+				*ppv = cast(void*) cast(T) this;
+			}
+			else {
+				*ppv = null;
+				return E_NOINTERFACE;
+			}
+
+			AddRef();
+			return NOERROR;
+		}
+
+		shared LONG count = 0;
+		ULONG AddRef() {
+			return atomicOp!"+="(count, 1);
+		}
+		ULONG Release() {
+			return atomicOp!"-="(count, 1);
+		}
+	};
+}
+
+struct RC(T) {
+	private T object;
+	this(T t) {
+		object = t;
+		object.AddRef();
+	}
+	this(this) {
+		if(object is null) return;
+		object.AddRef();
+	}
+	~this() {
+		if(object is null) return;
+		object.Release();
+		object = null;
+	}
+
+	void opAssign(T obj) {
+		obj.AddRef();
+		if(object)
+			object.Release();
+		this.object = obj;
+	}
+
+	T returnable() {
+		if(object is null) return null;
+		return object;
+	}
+
+	T passable() {
+		if(object is null) return null;
+		object.AddRef();
+		return object;
+	}
+
+	static foreach(memberName; __traits(derivedMembers, T)) {
+		mixin ForwardMethod!(memberName);
+	}
+}
+
+class ComException : Exception {
+	HRESULT errorCode;
+	this(HRESULT errorCode) {
+		import std.format;
+		super(format("HRESULT: 0x%08x", errorCode));
+		// FIXME: call FormatMessage
+	}
+}
+
+mixin template ForwardMethod(string methodName) {
+	static if(methodName.length > 4 && methodName[0 .. 4] == "put_") {
+		static if(is(typeof(__traits(getMember, T, memberName)) Params == function))
+			private alias Type = Params[0];
+		mixin(q{ @property void } ~ memberName[4 .. $] ~ q{(Type v) {
+			auto errorCode = __traits(getMember, object, memberName)(v);
+			if(errorCode)
+				throw new ComException(errorCode);
+		}
+		});
+	} else
+	static if(methodName.length > 4 && methodName[0 .. 4] == "get_") {
+		static if(is(typeof(__traits(getMember, T, memberName)) Params == function))
+			private alias Type = typeof(*(Params[0].init));
+		mixin(q{ @property Type } ~ memberName[4 .. $] ~ q{() {
+			Type response;
+			auto errorCode = __traits(getMember, object, memberName)(&response);
+			if(errorCode)
+				throw new ComException(errorCode);
+			return response;
+		}
+		});
+	} else
+	static if(methodName.length > 4 && methodName[0 .. 4] == "add_") {
+		static if(is(typeof(__traits(getMember, T, memberName)) Params == function))
+			alias Handler = Params[0];
+		alias HandlerDg = typeof(&Handler.init.Invoke);
+		mixin(q{ EventRegistrationToken } ~ memberName ~ q{ (HandlerDg handler) {
+			EventRegistrationToken token;
+			__traits(getMember, object, memberName)(callback!Handler(handler), &token);
+			return token;
+		}});
+	} else
+	static if(methodName.length > 7 && methodName[0 .. 4] == "remove_") {
+		mixin(q{ void } ~ memberName ~ q{ (EventRegistrationToken token) {
+			__traits(getMember, object, memberName)(token);
+		}});
+	} else {
+		// I could do the return value things by looking for these comments:
+		// /+[out]+/ but be warned it is possible or a thing to have multiple out params (only one such function in here though i think)
+		// /+[out, retval]+/
+		// a find/replace could make them a UDA or something.
+
+		static if(is(typeof(__traits(getMember, T, memberName)) Params == function))
+		static if(is(typeof(__traits(getMember, T, memberName)) Return == return))
+
+		mixin(q{ Return } ~ memberName ~ q{ (Params p) {
+			// FIXME: check the return value and throw
+			return __traits(getMember, object, memberName)(p);
+		}
+		});
+
+	}
+}
+
+struct Wv2App {
+	static bool active = false;
+
+	static HRESULT code;
+	static bool initialized = false;
+	static RC!ICoreWebView2Environment webview_env;
+
+	@disable this(this);
+
+	static void delegate(RC!ICoreWebView2Environment)[] pending;
+	this(void delegate(RC!ICoreWebView2Environment) withEnvironment) {
+		if(withEnvironment)
+			pending ~= withEnvironment;
+
+		import core.sys.windows.com;
+		CoInitializeEx(null, COINIT_APARTMENTTHREADED);
+
+		active = true;
+
+		auto lib = LoadLibraryW("WebView2Loader.dll"w.ptr);
+		typeof(&CreateCoreWebView2EnvironmentWithOptions) func;
+
+		if(lib is null)
+			throw new Exception("WebView2Loader.dll unable to load. The developer should bundle this with the application exe. It is found with the WebView2 SDK from nuget.");
+		func = cast(typeof(func)) GetProcAddress(lib, CreateCoreWebView2EnvironmentWithOptions.mangleof);
+		if(func is null)
+			throw new Exception("CreateCoreWebView2EnvironmentWithOptions failed from WebView2Loader...");
+
+		auto result = func(null, null, null,
+			callback!(ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler)(
+				delegate(error, env) {
+					initialized = true;
+					code = error;
+
+					if(error)
+						return error;
+
+					webview_env = env;
+
+					auto len = pending.length;
+					foreach(item; pending) {
+						item(webview_env);
+					}
+
+					pending = pending[len .. $];
+
+					return S_OK;
+				}
+			)
+		);
+
+		if(result != S_OK) {
+			if(MessageBox(null, "The WebView2 runtime is not installed. Would you like to install it now? This will open a browser to download a file. After it installs, you can try running this program again.", "Missing file", MB_YESNO) == IDYES) {
+				import std.process;
+				browse("https://go.microsoft.com/fwlink/p/?LinkId=2124703");
+			}
+			throw new ComException(result);
+		}
+	}
+
+	@disable this();
+
+	~this() {
+		active = false;
+	}
+
+	static void useEnvironment(void delegate(RC!ICoreWebView2Environment) withEnvironment) {
+		assert(active);
+		assert(withEnvironment !is null);
+		if(initialized) {
+			if(code)
+				throw new ComException(code);
+			withEnvironment(webview_env);
+		} else
+			pending ~= withEnvironment;
+	}
+}
+}
+
+
+
+/+
+interface WebView {
+	void refresh();
+	void back();
+	void forward();
+	void stop();
+
+	void navigate(string url);
+
+	// the url and line are for error reporting purposes
+	void executeJavascript(string code, string url = null, int line = 0);
+
+	void showDevTools();
+
+	// these are get/set properties that you can subscribe to with some system
+
+	mixin Observable!(string, "title");
+	mixin Observable!(string, "url");
+	mixin Observable!(string, "status");
+	mixin Observable!(int, "loadingProgress");
+}
++/
+
+
+version(linux) {
+version(linux_gtk) {} else
+	version=cef;
+}
+
+
 version(cef) {
 import arsd.simpledisplay;
 
-pragma(lib, "cef");
-
-class MyCefClient : CEF!cef_client_t {
-	MyCefLifeSpanHandler lsh;
-	this() {
-		lsh = new MyCefLifeSpanHandler();
-	}
-
-	override _cef_audio_handler_t* get_audio_handler() {
-		return null;
-	}
-	override _cef_context_menu_handler_t* get_context_menu_handler() {
-		return null;
-	}
-	override _cef_dialog_handler_t* get_dialog_handler() {
-		return null;
-	}
-	override _cef_display_handler_t* get_display_handler() {
-		return null;
-	}
-	override _cef_download_handler_t* get_download_handler() {
-		return null;
-	}
-	override _cef_drag_handler_t* get_drag_handler() {
-		return null;
-	}
-	override _cef_find_handler_t* get_find_handler() {
-		return null;
-	}
-	override _cef_focus_handler_t* get_focus_handler() {
-		return null;
-	}
-	override _cef_jsdialog_handler_t* get_jsdialog_handler() {
-		return null;
-	}
-	override _cef_keyboard_handler_t* get_keyboard_handler() {
-		return null;
-	}
-	override _cef_life_span_handler_t* get_life_span_handler() {
-		return lsh.returnable;
-	}
-	override _cef_load_handler_t* get_load_handler() {
-		return null;
-	}
-	override _cef_render_handler_t* get_render_handler() {
-		return null;
-	}
-	override _cef_request_handler_t* get_request_handler() {
-		return null;
-	}
-	override int on_process_message_received(RC!_cef_browser_t, RC!_cef_frame_t, cef_process_id_t, RC!_cef_process_message_t) {
-		// FIXME: supposed to release references
-		return 0; // return 1 if you can actually handle the message
-	}
-}
-
-// FIXME: make a CefStruct thing that refcounts and just forwards automatically for the parameters.
-
-class MyCefLifeSpanHandler : CEF!cef_life_span_handler_t {
-	override int on_before_popup(RC!_cef_browser_t, RC!_cef_frame_t, const(_cef_string_utf16_t)*, const(_cef_string_utf16_t)*, cef_window_open_disposition_t, int, const(_cef_popup_features_t)*, _cef_window_info_t*, _cef_client_t**, _cef_browser_settings_t*, _cef_dictionary_value_t**, int*) {
-		// FIXME: supposed to release references
-		return 0;
-	}
-	override void on_after_created(RC!_cef_browser_t browser) {
-	/*
-		auto frame = browser.get_main_frame();
-		cef_string_t omg = cef_string_t("http://dpldocs.info"w);
-		frame.load_url(frame, &omg);
-	*/
-	}
-	override int do_close(RC!_cef_browser_t browser) {
-		return 0;
-	}
-	override void on_before_close(RC!_cef_browser_t browser) {
-	}
-}
+//pragma(lib, "cef");
 
 class BrowserProcessHandler : CEF!cef_browser_process_handler_t {
-	override void get_cookieable_schemes(void*, int* includeDefaults) { *includeDefaults = 1; }
 	override void on_context_initialized() { }
-	override _cef_print_handler_t* get_print_handler() {
-		return null;
-	}
 
-	override void on_before_child_process_launch(RC!_cef_command_line_t) { }
+	override void on_before_child_process_launch(RC!cef_command_line_t) { }
 	override void on_schedule_message_pump_work(long delayMs) { }
-	override _cef_client_t* get_default_client() { return null; }
+	override cef_client_t* get_default_client() { return null; }
 }
 
 
@@ -114,38 +315,63 @@ int cefProcessHelper() {
 	import core.stdc.stdlib;
 
 	cef_main_args_t main_args;
-	main_args.argc = Runtime.cArgs.argc;
-	main_args.argv = Runtime.cArgs.argv;
+	version(linux) {
+		main_args.argc = Runtime.cArgs.argc;
+		main_args.argv = Runtime.cArgs.argv;
+	} else version(Windows) {
+		main_args.instance = GetModuleHandle(null);
+	}
 
-	int code = cef_execute_process(&main_args, null, null);
-	if(code >= 0)
-		exit(code);
-	return code;
+	if(libcef.loadDynamicLibrary()) {
+		int code = libcef.execute_process(&main_args, null, null);
+		if(code >= 0)
+			exit(code);
+		return code;
+	}
+	return -1;
 }
 
 shared static this() {
 	cefProcessHelper();
 }
 
-struct CefApp {
+public struct CefApp {
+	static bool active() {
+		return count > 0;
+	}
+
+	private __gshared int count = 0;
+
 	@disable this(this);
 	@disable new();
 	this(void delegate(cef_settings_t* settings) setSettings) {
+
+		if(!libcef.loadDynamicLibrary())
+			throw new Exception("failed to load cef dll");
+
+		count++;
+
 		import core.runtime;
 		import core.stdc.stdlib;
 
 		cef_main_args_t main_args;
-		main_args.argc = Runtime.cArgs.argc;
-		main_args.argv = Runtime.cArgs.argv;
+		version(linux) {
+			main_args.argc = Runtime.cArgs.argc;
+			main_args.argv = Runtime.cArgs.argv;
+		} else version(Windows) {
+			main_args.instance = GetModuleHandle(null);
+		}
 
 		cef_settings_t settings;
 		settings.size = cef_settings_t.sizeof;
-		settings.log_severity = cef_log_severity_t.LOGSEVERITY_DISABLE; // Show only warnings/errors
-		//settings.log_severity = cef_log_severity_t.LOGSEVERITY_WARNING; // Show only warnings/errors
-		//settings.external_message_pump = 1;
+		//settings.log_severity = cef_log_severity_t.LOGSEVERITY_DISABLE; // Show only warnings/errors
+		settings.log_severity = cef_log_severity_t.LOGSEVERITY_INFO; // Show only warnings/errors
 		settings.multi_threaded_message_loop = 1;
 		settings.no_sandbox = 1;
 
+		version(linux)
+		settings.locales_dir_path = cef_string_t("/opt/cef/Resources/locales");
+
 		if(setSettings !is null)
 			setSettings(&settings);
 
@@ -157,31 +383,35 @@ struct CefApp {
 			}
 			override void on_before_command_line_processing(const(cef_string_t)*, RC!cef_command_line_t) {}
 
-			override _cef_resource_bundle_handler_t* get_resource_bundle_handler() {
+			override cef_resource_bundle_handler_t* get_resource_bundle_handler() {
 				return null;
 			}
-			override _cef_browser_process_handler_t* get_browser_process_handler() {
+			override cef_browser_process_handler_t* get_browser_process_handler() {
 				return bph.returnable;
 			}
-			override _cef_render_process_handler_t* get_render_process_handler() {
+			override cef_render_process_handler_t* get_render_process_handler() {
 				return null;
 			}
-			override void on_register_custom_schemes(_cef_scheme_registrar_t*) {
+			override void on_register_custom_schemes(cef_scheme_registrar_t*) {
 
 			}
 		};
 
-		if(!cef_initialize(&main_args, &settings, app.passable, null)) {
+		if(!libcef.initialize(&main_args, &settings, app.passable, null)) {
 			throw new Exception("cef_initialize failed");
 		}
 	}
 
 	~this() {
-		cef_shutdown();
+		count--;
+		// this call hangs and idk why.
+		// FIXME
+		//libcef.shutdown();
 	}
 }
 
 
+version(Demo)
 void main() {
 	auto app = CefApp(null);
 
@@ -197,7 +427,7 @@ void main() {
 	*/
 	//window_info.parent_window = window.nativeWindowHandle;
 
-	cef_string_t cef_url = cef_string_t("http://youtube.com/"w);
+	cef_string_t cef_url = cef_string_t("http://dpldocs.info/");//"http://youtube.com/"w);
 
 	//string url = "http://arsdnet.net/";
 	//cef_string_utf8_to_utf16(url.ptr, url.length, &cef_url);
@@ -207,10 +437,78 @@ void main() {
 
 	auto client = new MyCefClient();
 
-	auto got = cef_browser_host_create_browser(&window_info, client.passable, &cef_url, &browser_settings, null, null); // or _sync
+	auto got = libcef.browser_host_create_browser(&window_info, client.passable, &cef_url, &browser_settings, null, null); // or _sync
 
 	window.eventLoop(0);
 }
+
+
+/++
+	This gives access to the CEF functions. If you get a linker error for using an undefined function,
+	it is probably because you did NOT go through this when dynamically loading.
+
+	(...similarly, if you get a segfault, it is probably because you DID go through this when static binding.)
++/
+struct libcef {
+	static __gshared:
+
+	bool isLoaded;
+	bool loadAttempted;
+	void* libHandle;
+
+	/// Make sure you call this only from one thread, probably at process startup. It caches internally and returns true if the load was successful.
+	bool loadDynamicLibrary() {
+		if(loadAttempted)
+			return isLoaded;
+
+		loadAttempted = true;
+
+		version(linux) {
+			import core.sys.posix.dlfcn;
+			libHandle = dlopen("libcef.so", RTLD_NOW);
+
+			static void* loadsym(const char* name) {
+				return dlsym(libHandle, name);
+			}
+		} else version(Windows) {
+			import core.sys.windows.windows;
+			libHandle = LoadLibrary("libcef.dll");
+
+			static void* loadsym(const char* name) {
+				return GetProcAddress(libHandle, name);
+			}
+		}
+
+		//import std.stdio;
+		if(libHandle is null) {
+		//writeln("libhandlenull");
+			return false;
+		}
+		foreach(memberName; __traits(allMembers, libcef)[4 .. $]) { // cutting off everything until the actual static foreach below; this trims off isLoaded to loadDynamicLibrary
+			alias mem = __traits(getMember, libcef, memberName);
+			mem = cast(typeof(mem)) loadsym("cef_" ~ memberName);
+			if(mem is null) {
+				// writeln(memberName);
+				// throw new Exception("cef_" ~ memberName ~ " failed to load");
+				return false;
+			}
+		}
+
+		import core.stdc.string;
+		if(strcmp(libcef.api_hash(1), CEF_API_HASH_UNIVERSAL) != 0)
+			throw new Exception("libcef versions not matching bindings");
+
+		isLoaded = true;
+		return true;
+	}
+
+	static foreach(memberName; __traits(allMembers, arsd.webview))
+	static if(is(typeof(__traits(getMember, arsd.webview, memberName)) == function))
+	static if(memberName.length > 4 && memberName[0 .. 4] == "cef_") {
+		mixin(q{ typeof(&__traits(getMember, arsd.webview, memberName)) } ~ memberName[4 .. $] ~ ";"); // = &" ~ memberName ~ ";");
+	}
+}
+
 }
 
 version(linux_gtk)
@@ -362,7 +660,7 @@ private extern(C) {
 	alias msg_cb_t = void function(const char *msg);
 }
 
-version(WEBVIEW_GTK) {
+version(linux_gtk) {
 
 
 /* Original https://github.com/zserge/webview notice below:
@@ -746,7 +1044,7 @@ abstract class CEF(Base) {
 		}
 	}
 
-	private static nothrow @nogc extern(C) {
+	private static nothrow @nogc extern(System) {
 		void c_add_ref(cef_base_ref_counted_t* self) {
 			return ((cast(Inner*) self).d_object).add_ref();
 		}
@@ -814,7 +1112,7 @@ private mixin template AbstractMethod(string name) {
 		// mixin(q{abstract nothrow Return } ~ name ~ q{(Params[1 .. $] p);});
 
 		mixin(q{
-		private static nothrow extern(C)
+		private static nothrow extern(System)
 		Return c_}~name~q{(Params p) {
 			Base* self = p[0]; // a bit of a type check here...
 			auto dobj = (cast(Inner*) self).d_object; // ...before this cast.
@@ -894,6 +1192,9 @@ struct RC(Base) {
 		inner.base.release(&inner.base);
 		inner = null;
 	}
+	bool opCast(T:bool)() nothrow {
+		return inner !is null;
+	}
 
 	Base* getRawPointer() nothrow {
 		return inner;
@@ -902,6 +1203,7 @@ struct RC(Base) {
 	Base* passable() nothrow {
 		if(inner is null)
 			return inner;
+
 		inner.base.add_ref(&inner.base);
 		return inner;
 	}
@@ -913,7 +1215,6 @@ struct RC(Base) {
 			mixin(q{final ref @property } ~ memberName ~ q{() { return __traits(getMember, inner, memberName); }});
 		}
 	}
-
 }
 
 auto cefToD(T)(T t) {
@@ -924,26 +1225,70 @@ auto cefToD(T)(T t) {
 	}
 }
 
-// bindings follow, first some hand-written ones for Linux, then some machine translated things.
 
+string toGC(const cef_string_utf16_t str) nothrow {
+	if(str.str is null)
+		return null;
+
+	string s;
+	s.reserve(str.length);
+
+	try
+	foreach(char ch; str.str[0 .. str.length])
+		s ~= ch;
+	catch(Exception e) {}
+	return s;
+}
+
+string toGC(const cef_string_utf16_t* str) nothrow {
+	if(str is null)
+		return null;
+	return toGC(*str);
+}
+
+string toGCAndFree(const cef_string_userfree_t str) nothrow {
+	if(str is null)
+		return null;
+
+	string s = toGC(str);
+	libcef.string_userfree_utf16_free(str);
+	//str = null;
+	return s;
+}
+
+// bindings follow, first some hand-written ones for Linux, then some machine translated things. More comments about the machine translation when it comes.
+
+version(linux)
 struct cef_main_args_t {
 	int argc;
 	char** argv;
 }
-alias _cef_main_args_t = cef_main_args_t;
+version(Windows)
+struct cef_main_args_t {
+	HINSTANCE instance;
+}
 
-extern(C)
+// 0 - CEF_VERSION_MAJOR
+// 1 - CEF_VERSION_MINOR
+// 2 - CEF_VERSION_PATCH
+// 3 - CEF_COMMIT_NUMBER
+// 4 - CHROME_VERSION_MAJOR
+// 5 - CHROME_VERSION_MINOR
+// 6 - CHROME_VERSION_BUILD
+// 7 - CHROME_VERSION_PATCH
+
+extern(C) nothrow
 int cef_string_utf8_to_utf16(const char* src, size_t src_len, cef_string_utf16_t* output);
 
-struct _cef_string_utf8_t {
+struct cef_string_utf8_t {
   char* str;
   size_t length;
   void* dtor;// void (*dtor)(char* str);
 }
 
-alias cef_string_utf8_t = _cef_string_utf8_t;
 
-struct _cef_string_utf16_t {
+
+struct cef_string_utf16_t {
   char16* str;
   size_t length;
   void* dtor; // voiod (*dtor)(char16* str);
@@ -952,12 +1297,18 @@ struct _cef_string_utf16_t {
 	this.str = cast(char16*) s.ptr;
 	this.length = s.length;
   }
-}
 
-alias _cef_string_utf16_t cef_string_utf16_t;
+  this(string s) nothrow {
+	libcef.string_utf8_to_utf16(s.ptr, s.length, &this);
+  }
+}
 
 alias cef_string_t = cef_string_utf16_t;
 alias cef_window_handle_t = NativeWindowHandle;
+version(Windows)
+	alias cef_cursor_handle_t = HCURSOR;
+else
+	alias cef_cursor_handle_t = XID;
 
 struct cef_time_t {
   int year;          // Four or five digit year "2007" (1601 to 30827 on
@@ -972,7 +1323,8 @@ struct cef_time_t {
   int millisecond;   // Milliseconds within the current second (0-999)
 }
 
-struct _cef_window_info_t {
+version(linux)
+struct cef_window_info_t {
   cef_string_t window_name;
 
   uint x;
@@ -991,7 +1343,21 @@ struct _cef_window_info_t {
   cef_window_handle_t window;
 }
 
-alias cef_window_info_t = _cef_window_info_t;
+version(Windows)
+struct cef_window_info_t {
+	DWORD ex_style;
+	cef_string_t window_name;
+	DWORD style;
+	cef_rect_t bounds;
+	cef_window_handle_t parent_window;
+	HMENU menu;
+	int windowless_rendering_enabled;
+	int shared_texture_enabled;
+	int external_begin_frame_enabled;
+	cef_window_handle_t window;
+}
+
+
 
 import core.stdc.config;
 alias int16 = short;
@@ -1002,10 +1368,22 @@ alias char16 = wchar;
 alias int64 = long;
 alias uint64 = ulong;
 
-// FIXME
-alias cef_string_list_t = void*;
-alias cef_string_multimap_t = void*;
-alias cef_string_map_t = void*;
+// these are supposed to just be opaque pointers but i want some type safety. this same abi wise.......... RIGHT?
+struct cef_string_list_t { void* r; }
+struct cef_string_multimap_t { void* r; }
+struct cef_string_map_t { void* r; }
+
+
+extern(C) nothrow {
+	cef_string_list_t cef_string_list_alloc();
+	size_t cef_string_list_size(cef_string_list_t list);
+	int cef_string_list_value(cef_string_list_t list, size_t index, cef_string_t* value);
+	void cef_string_list_append(cef_string_list_t list, const cef_string_t* value);
+	void cef_string_list_clear(cef_string_list_t list);
+	void cef_string_list_free(cef_string_list_t list);
+	cef_string_list_t cef_string_list_copy(cef_string_list_t list);
+}
+
 
 version(linux) {
 	import core.sys.posix.sys.types;
@@ -1017,20 +1395,32 @@ version(linux) {
 	alias OS_EVENT = void;
 }
 
-nothrow @nogc extern(C) void cef_string_userfree_utf16_free(cef_string_userfree_utf16_t str);
-alias cef_string_userfree_t = const(wchar)*;
-alias cef_string_userfree_utf16_t = const(wchar)*;
+nothrow @nogc extern(C) void cef_string_userfree_utf16_free(const cef_string_userfree_utf16_t str);
+struct cef_string_userfree_utf16_t { cef_string_utf16_t* it; alias it this; }
+alias cef_string_userfree_t = cef_string_userfree_utf16_t;
 
-static assert(cef_app_t.sizeof == 80);
-static assert(cef_settings_t.sizeof == 440);
-static assert(cef_window_info_t.sizeof == 72);
-static assert(cef_string_t.sizeof == 24);
-static assert(cef_client_t.sizeof == 160);
+// **************
 
 // cef/include/capi$ for i in *.h; do dstep -I../.. $i; done
+// also dstep include/cef_version.h
+// update the CEF_VERSION and the CEF_API_HASH_UNIVERSAL out of cef_version.h and cef_api_hash.h
 // then concatenate the bodies of them and delete the translated macros and `struct .*;` stuff
+// then I added nothrow to all function pointers with a vim macro (`/function (<ENTER>e%a nothrow<ESC>` then just hold in @ to do the @@ repeat macro command until it was done
+// then select all and global replace s/_cef/cef/g
+// then delete the pointless aliases find with `/alias \(.*\) = \1;` and delete with 2dd. macros can do the job or just simple global replace to nothing. blank lines don't matter.
 
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
+// and make sure version(linux) void cef_register_widevine_cdm ( if it is there.
+
+// and extern (C) is wrong on the callbacks, they should all be extern(System)
+// `/function (<ENTER>Oextern(System)<ESC>`
+
+
+version=embedded_cef_bindings;
+
+// everything inside these brackets are the bindings you can replace if update needed
+
+version(embedded_cef_bindings) {
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -1061,48 +1451,43 @@ static assert(cef_client_t.sizeof == 160);
 //
 // ---------------------------------------------------------------------------
 //
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=00d5124d346e3f3cc3f53d67bcb766d1d798bf12$
+// This file was generated by the make_version_header.py tool.
 //
 
 extern (C):
 
+enum CEF_VERSION = "95.7.17+g4208276+chromium-95.0.4638.69";
+enum CEF_VERSION_MAJOR = 95;
+enum CEF_VERSION_MINOR = 7;
+enum CEF_VERSION_PATCH = 17;
+enum CEF_COMMIT_NUMBER = 2459;
+enum CEF_COMMIT_HASH = "4208276762b1f52ed444debd7caa84fc3332e6a9";
+enum COPYRIGHT_YEAR = 2021;
+
+enum CHROME_VERSION_MAJOR = 95;
+enum CHROME_VERSION_MINOR = 0;
+enum CHROME_VERSION_BUILD = 4638;
+enum CHROME_VERSION_PATCH = 69;
+
+
+
+// Returns CEF version information for the libcef library. The |entry|
+// parameter describes which version component will be returned:
+// 0 - CEF_VERSION_MAJOR
+// 1 - CEF_VERSION_MINOR
+// 2 - CEF_VERSION_PATCH
+// 3 - CEF_COMMIT_NUMBER
+// 4 - CHROME_VERSION_MAJOR
+// 5 - CHROME_VERSION_MINOR
+// 6 - CHROME_VERSION_BUILD
+// 7 - CHROME_VERSION_PATCH
 ///
-// Implement this structure to receive accessibility notification when
-// accessibility events have been registered. The functions of this structure
-// will be called on the UI thread.
-///
-struct _cef_accessibility_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
+int cef_version_info (int entry);
 
-    ///
-    // Called after renderer process sends accessibility tree changes to the
-    // browser process.
-    ///
-    void function (
-        _cef_accessibility_handler_t* self,
-        _cef_value_t* value) nothrow on_accessibility_tree_change;
+// APSTUDIO_HIDDEN_SYMBOLS
 
-    ///
-    // Called after renderer process sends accessibility location changes to the
-    // browser process.
-    ///
-    void function (
-        _cef_accessibility_handler_t* self,
-        _cef_value_t* value) nothrow on_accessibility_location_change;
-}
-
-alias cef_accessibility_handler_t = _cef_accessibility_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
+// CEF_INCLUDE_CEF_VERSION_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -1133,345 +1518,31 @@ alias cef_accessibility_handler_t = _cef_accessibility_handler_t;
 //
 // ---------------------------------------------------------------------------
 //
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=04cfae434fe901644c1c78f1c30c0921518cc666$
+// This file was generated by the make_api_hash_header.py tool.
 //
 
 extern (C):
 
-///
-// Implement this structure to provide handler implementations. Methods will be
-// called by the process and/or thread indicated.
-///
-struct _cef_app_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
+// The API hash is created by analyzing CEF header files for C API type
+// definitions. The hash value will change when header files are modified in a
+// way that may cause binary incompatibility with other builds. The universal
+// hash value will change if any platform is affected whereas the platform hash
+// values will change only if that particular platform is affected.
+enum CEF_API_HASH_UNIVERSAL = "21ac25aebdb49a8e8088c6fbee802b04fd07b501";
 
-    ///
-    // Provides an opportunity to view and/or modify command-line arguments before
-    // processing by CEF and Chromium. The |process_type| value will be NULL for
-    // the browser process. Do not keep a reference to the cef_command_line_t
-    // object passed to this function. The CefSettings.command_line_args_disabled
-    // value can be used to start with an NULL command-line object. Any values
-    // specified in CefSettings that equate to command-line arguments will be set
-    // before this function is called. Be cautious when using this function to
-    // modify command-line arguments for non-browser processes as this may result
-    // in undefined behavior including crashes.
-    ///
-    void function (
-        _cef_app_t* self,
-        const(cef_string_t)* process_type,
-        _cef_command_line_t* command_line) nothrow on_before_command_line_processing;
-
-    ///
-    // Provides an opportunity to register custom schemes. Do not keep a reference
-    // to the |registrar| object. This function is called on the main thread for
-    // each process and the registered schemes should be the same across all
-    // processes.
-    ///
-    void function (
-        _cef_app_t* self,
-        _cef_scheme_registrar_t* registrar) nothrow on_register_custom_schemes;
-
-    ///
-    // Return the handler for resource bundle events. If
-    // CefSettings.pack_loading_disabled is true (1) a handler must be returned.
-    // If no handler is returned resources will be loaded from pack files. This
-    // function is called by the browser and render processes on multiple threads.
-    ///
-    _cef_resource_bundle_handler_t* function (
-        _cef_app_t* self) nothrow get_resource_bundle_handler;
-
-    ///
-    // Return the handler for functionality specific to the browser process. This
-    // function is called on multiple threads in the browser process.
-    ///
-    _cef_browser_process_handler_t* function (
-        _cef_app_t* self) nothrow get_browser_process_handler;
-
-    ///
-    // Return the handler for functionality specific to the render process. This
-    // function is called on the render process main thread.
-    ///
-    _cef_render_process_handler_t* function (
-        _cef_app_t* self) nothrow get_render_process_handler;
-}
-
-alias cef_app_t = _cef_app_t;
+enum CEF_API_HASH_PLATFORM = "0b5227787444955a548b7544b2cdcda95a354506";
 
 ///
-// This function should be called from the application entry point function to
-// execute a secondary process. It can be used to run secondary processes from
-// the browser client executable (default behavior) or from a separate
-// executable specified by the CefSettings.browser_subprocess_path value. If
-// called for the browser process (identified by no "type" command-line value)
-// it will return immediately with a value of -1. If called for a recognized
-// secondary process it will block until the process should exit and then return
-// the process exit code. The |application| parameter may be NULL. The
-// |windows_sandbox_info| parameter is only used on Windows and may be NULL (see
-// cef_sandbox_win.h for details).
+// Returns CEF API hashes for the libcef library. The returned string is owned
+// by the library and should not be freed. The |entry| parameter describes which
+// hash value will be returned:
+// 0 - CEF_API_HASH_PLATFORM
+// 1 - CEF_API_HASH_UNIVERSAL
+// 2 - CEF_COMMIT_HASH (from cef_version.h)
 ///
-int cef_execute_process (
-    const(_cef_main_args_t)* args,
-    cef_app_t* application,
-    void* windows_sandbox_info);
+const(char)* cef_api_hash (int entry);
 
-///
-// This function should be called on the main application thread to initialize
-// the CEF browser process. The |application| parameter may be NULL. A return
-// value of true (1) indicates that it succeeded and false (0) indicates that it
-// failed. The |windows_sandbox_info| parameter is only used on Windows and may
-// be NULL (see cef_sandbox_win.h for details).
-///
-int cef_initialize (
-    const(_cef_main_args_t)* args,
-    const(_cef_settings_t)* settings,
-    cef_app_t* application,
-    void* windows_sandbox_info);
-
-///
-// This function should be called on the main application thread to shut down
-// the CEF browser process before the application exits.
-///
-void cef_shutdown ();
-
-///
-// Perform a single iteration of CEF message loop processing. This function is
-// provided for cases where the CEF message loop must be integrated into an
-// existing application message loop. Use of this function is not recommended
-// for most users; use either the cef_run_message_loop() function or
-// CefSettings.multi_threaded_message_loop if possible. When using this function
-// care must be taken to balance performance against excessive CPU usage. It is
-// recommended to enable the CefSettings.external_message_pump option when using
-// this function so that
-// cef_browser_process_handler_t::on_schedule_message_pump_work() callbacks can
-// facilitate the scheduling process. This function should only be called on the
-// main application thread and only if cef_initialize() is called with a
-// CefSettings.multi_threaded_message_loop value of false (0). This function
-// will not block.
-///
-nothrow void cef_do_message_loop_work ();
-
-///
-// Run the CEF message loop. Use this function instead of an application-
-// provided message loop to get the best balance between performance and CPU
-// usage. This function should only be called on the main application thread and
-// only if cef_initialize() is called with a
-// CefSettings.multi_threaded_message_loop value of false (0). This function
-// will block until a quit message is received by the system.
-///
-void cef_run_message_loop ();
-
-///
-// Quit the CEF message loop that was started by calling cef_run_message_loop().
-// This function should only be called on the main application thread and only
-// if cef_run_message_loop() was used.
-///
-void cef_quit_message_loop ();
-
-///
-// Set to true (1) before calling Windows APIs like TrackPopupMenu that enter a
-// modal message loop. Set to false (0) after exiting the modal message loop.
-///
-void cef_set_osmodal_loop (int osModalLoop);
-
-///
-// Call during process startup to enable High-DPI support on Windows 7 or newer.
-// Older versions of Windows should be left DPI-unaware because they do not
-// support DirectWrite and GDI fonts are kerned very badly.
-///
-void cef_enable_highdpi_support ();
-
-// CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=430877d950508a545d0baa18c8c8c0d2d183fec4$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle audio events.
-///
-struct _cef_audio_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called on the UI thread to allow configuration of audio stream parameters.
-    // Return true (1) to proceed with audio stream capture, or false (0) to
-    // cancel it. All members of |params| can optionally be configured here, but
-    // they are also pre-filled with some sensible defaults.
-    ///
-    int function (
-        _cef_audio_handler_t* self,
-        _cef_browser_t* browser,
-        cef_audio_parameters_t* params) nothrow get_audio_parameters;
-
-    ///
-    // Called on a browser audio capture thread when the browser starts streaming
-    // audio. OnAudioSteamStopped will always be called after
-    // OnAudioStreamStarted; both functions may be called multiple times for the
-    // same browser. |params| contains the audio parameters like sample rate and
-    // channel layout. |channels| is the number of channels.
-    ///
-    void function (
-        _cef_audio_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_audio_parameters_t)* params,
-        int channels) nothrow on_audio_stream_started;
-
-    ///
-    // Called on the audio stream thread when a PCM packet is received for the
-    // stream. |data| is an array representing the raw PCM data as a floating
-    // point type, i.e. 4-byte value(s). |frames| is the number of frames in the
-    // PCM packet. |pts| is the presentation timestamp (in milliseconds since the
-    // Unix Epoch) and represents the time at which the decompressed packet should
-    // be presented to the user. Based on |frames| and the |channel_layout| value
-    // passed to OnAudioStreamStarted you can calculate the size of the |data|
-    // array in bytes.
-    ///
-    void function (
-        _cef_audio_handler_t* self,
-        _cef_browser_t* browser,
-        const(float*)* data,
-        int frames,
-        int64 pts) nothrow on_audio_stream_packet;
-
-    ///
-    // Called on the UI thread when the stream has stopped. OnAudioSteamStopped
-    // will always be called after OnAudioStreamStarted; both functions may be
-    // called multiple times for the same stream.
-    ///
-    void function (
-        _cef_audio_handler_t* self,
-        _cef_browser_t* browser) nothrow on_audio_stream_stopped;
-
-    ///
-    // Called on the UI or audio stream thread when an error occurred. During the
-    // stream creation phase this callback will be called on the UI thread while
-    // in the capturing phase it will be called on the audio stream thread. The
-    // stream will be stopped immediately.
-    ///
-    void function (
-        _cef_audio_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* message) nothrow on_audio_stream_error;
-}
-
-alias cef_audio_handler_t = _cef_audio_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_AUDIO_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=58be0e24b46373bbdad28031891396ea246f446c$
-//
-
-extern (C):
-
-///
-// Callback structure used for asynchronous continuation of authentication
-// requests.
-///
-struct _cef_auth_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Continue the authentication request.
-    ///
-    void function (
-        _cef_auth_callback_t* self,
-        const(cef_string_t)* username,
-        const(cef_string_t)* password) nothrow cont;
-
-    ///
-    // Cancel the authentication request.
-    ///
-    void function (_cef_auth_callback_t* self) nothrow cancel;
-}
-
-alias cef_auth_callback_t = _cef_auth_callback_t;
-
-// CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
+// CEF_INCLUDE_API_HASH_H_
 // Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -1504,13168 +1575,54 @@ alias cef_auth_callback_t = _cef_auth_callback_t;
 extern (C):
 
 ///
-// All ref-counted framework structures must include this structure first.
+// Structure representing a point.
 ///
-struct _cef_base_ref_counted_t
+struct cef_point_t
 {
-    ///
-    // Size of the data structure.
-    ///
-    size_t size;
-
-    ///
-    // Called to increment the reference count for the object. Should be called
-    // for every new copy of a pointer to a given object.
-    ///
-    void function (_cef_base_ref_counted_t* self) nothrow add_ref;
-
-    ///
-    // Called to decrement the reference count for the object. If the reference
-    // count falls to 0 the object should self-delete. Returns true (1) if the
-    // resulting reference count is 0.
-    ///
-    int function (_cef_base_ref_counted_t* self) nothrow release;
-
-    ///
-    // Returns true (1) if the current reference count is 1.
-    ///
-    int function (_cef_base_ref_counted_t* self) nothrow has_one_ref;
-
-    ///
-    // Returns true (1) if the current reference count is at least 1.
-    ///
-    int function (_cef_base_ref_counted_t* self) nothrow has_at_least_one_ref;
-}
-
-alias cef_base_ref_counted_t = _cef_base_ref_counted_t;
-
-///
-// All scoped framework structures must include this structure first.
-///
-struct _cef_base_scoped_t
-{
-    ///
-    // Size of the data structure.
-    ///
-    size_t size;
-
-    ///
-    // Called to delete this object. May be NULL if the object is not owned.
-    ///
-    void function (_cef_base_scoped_t* self) del;
-}
-
-alias cef_base_scoped_t = _cef_base_scoped_t;
-
-// CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=965eb2e55afec0a4618a7acd9478b9c1215be29d$
-//
-
-import core.stdc.config;
-
-extern (C):
-
-///
-// Structure used to represent a browser window. When used in the browser
-// process the functions of this structure may be called on any thread unless
-// otherwise indicated in the comments. When used in the render process the
-// functions of this structure may only be called on the main thread.
-///
-struct _cef_browser_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the browser host object. This function can only be called in the
-    // browser process.
-    ///
-    _cef_browser_host_t* function (_cef_browser_t* self) nothrow get_host;
-
-    ///
-    // Returns true (1) if the browser can navigate backwards.
-    ///
-    int function (_cef_browser_t* self) nothrow can_go_back;
-
-    ///
-    // Navigate backwards.
-    ///
-    void function (_cef_browser_t* self) nothrow go_back;
-
-    ///
-    // Returns true (1) if the browser can navigate forwards.
-    ///
-    int function (_cef_browser_t* self) nothrow can_go_forward;
-
-    ///
-    // Navigate forwards.
-    ///
-    void function (_cef_browser_t* self) nothrow go_forward;
-
-    ///
-    // Returns true (1) if the browser is currently loading.
-    ///
-    int function (_cef_browser_t* self) nothrow is_loading;
-
-    ///
-    // Reload the current page.
-    ///
-    void function (_cef_browser_t* self) nothrow reload;
-
-    ///
-    // Reload the current page ignoring any cached data.
-    ///
-    void function (_cef_browser_t* self) nothrow reload_ignore_cache;
-
-    ///
-    // Stop loading the page.
-    ///
-    void function (_cef_browser_t* self) nothrow stop_load;
-
-    ///
-    // Returns the globally unique identifier for this browser. This value is also
-    // used as the tabId for extension APIs.
-    ///
-    int function (_cef_browser_t* self) nothrow get_identifier;
-
-    ///
-    // Returns true (1) if this object is pointing to the same handle as |that|
-    // object.
-    ///
-    int function (_cef_browser_t* self, _cef_browser_t* that) nothrow is_same;
-
-    ///
-    // Returns true (1) if the window is a popup window.
-    ///
-    int function (_cef_browser_t* self) nothrow is_popup;
-
-    ///
-    // Returns true (1) if a document has been loaded in the browser.
-    ///
-    int function (_cef_browser_t* self) nothrow has_document;
-
-    ///
-    // Returns the main (top-level) frame for the browser window.
-    ///
-    _cef_frame_t* function (_cef_browser_t* self) nothrow get_main_frame;
-
-    ///
-    // Returns the focused frame for the browser window.
-    ///
-    _cef_frame_t* function (_cef_browser_t* self) nothrow get_focused_frame;
-
-    ///
-    // Returns the frame with the specified identifier, or NULL if not found.
-    ///
-    _cef_frame_t* function (
-        _cef_browser_t* self,
-        int64 identifier) nothrow get_frame_byident;
-
-    ///
-    // Returns the frame with the specified name, or NULL if not found.
-    ///
-    _cef_frame_t* function (
-        _cef_browser_t* self,
-        const(cef_string_t)* name) nothrow get_frame;
-
-    ///
-    // Returns the number of frames that currently exist.
-    ///
-    size_t function (_cef_browser_t* self) nothrow get_frame_count;
-
-    ///
-    // Returns the identifiers of all existing frames.
-    ///
-    void function (
-        _cef_browser_t* self,
-        size_t* identifiersCount,
-        int64* identifiers) nothrow get_frame_identifiers;
-
-    ///
-    // Returns the names of all existing frames.
-    ///
-    void function (
-        _cef_browser_t* self,
-        cef_string_list_t names) nothrow get_frame_names;
-}
-
-alias cef_browser_t = _cef_browser_t;
-
-///
-// Callback structure for cef_browser_host_t::RunFileDialog. The functions of
-// this structure will be called on the browser process UI thread.
-///
-struct _cef_run_file_dialog_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called asynchronously after the file dialog is dismissed.
-    // |selected_accept_filter| is the 0-based index of the value selected from
-    // the accept filters array passed to cef_browser_host_t::RunFileDialog.
-    // |file_paths| will be a single value or a list of values depending on the
-    // dialog mode. If the selection was cancelled |file_paths| will be NULL.
-    ///
-    void function (
-        _cef_run_file_dialog_callback_t* self,
-        int selected_accept_filter,
-        cef_string_list_t file_paths) nothrow on_file_dialog_dismissed;
-}
-
-alias cef_run_file_dialog_callback_t = _cef_run_file_dialog_callback_t;
-
-///
-// Callback structure for cef_browser_host_t::GetNavigationEntries. The
-// functions of this structure will be called on the browser process UI thread.
-///
-struct _cef_navigation_entry_visitor_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be executed. Do not keep a reference to |entry| outside of
-    // this callback. Return true (1) to continue visiting entries or false (0) to
-    // stop. |current| is true (1) if this entry is the currently loaded
-    // navigation entry. |index| is the 0-based index of this entry and |total| is
-    // the total number of entries.
-    ///
-    int function (
-        _cef_navigation_entry_visitor_t* self,
-        _cef_navigation_entry_t* entry,
-        int current,
-        int index,
-        int total) nothrow visit;
-}
-
-alias cef_navigation_entry_visitor_t = _cef_navigation_entry_visitor_t;
-
-///
-// Callback structure for cef_browser_host_t::PrintToPDF. The functions of this
-// structure will be called on the browser process UI thread.
-///
-struct _cef_pdf_print_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be executed when the PDF printing has completed. |path| is
-    // the output path. |ok| will be true (1) if the printing completed
-    // successfully or false (0) otherwise.
-    ///
-    void function (
-        _cef_pdf_print_callback_t* self,
-        const(cef_string_t)* path,
-        int ok) nothrow on_pdf_print_finished;
-}
-
-alias cef_pdf_print_callback_t = _cef_pdf_print_callback_t;
-
-///
-// Callback structure for cef_browser_host_t::DownloadImage. The functions of
-// this structure will be called on the browser process UI thread.
-///
-struct _cef_download_image_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be executed when the image download has completed.
-    // |image_url| is the URL that was downloaded and |http_status_code| is the
-    // resulting HTTP status code. |image| is the resulting image, possibly at
-    // multiple scale factors, or NULL if the download failed.
-    ///
-    void function (
-        _cef_download_image_callback_t* self,
-        const(cef_string_t)* image_url,
-        int http_status_code,
-        _cef_image_t* image) nothrow on_download_image_finished;
-}
-
-alias cef_download_image_callback_t = _cef_download_image_callback_t;
-
-///
-// Structure used to represent the browser process aspects of a browser window.
-// The functions of this structure can only be called in the browser process.
-// They may be called on any thread in that process unless otherwise indicated
-// in the comments.
-///
-struct _cef_browser_host_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the hosted browser object.
-    ///
-    _cef_browser_t* function (_cef_browser_host_t* self) nothrow get_browser;
-
-    ///
-    // Request that the browser close. The JavaScript 'onbeforeunload' event will
-    // be fired. If |force_close| is false (0) the event handler, if any, will be
-    // allowed to prompt the user and the user can optionally cancel the close. If
-    // |force_close| is true (1) the prompt will not be displayed and the close
-    // will proceed. Results in a call to cef_life_span_handler_t::do_close() if
-    // the event handler allows the close or if |force_close| is true (1). See
-    // cef_life_span_handler_t::do_close() documentation for additional usage
-    // information.
-    ///
-    void function (_cef_browser_host_t* self, int force_close) nothrow close_browser;
-
-    ///
-    // Helper for closing a browser. Call this function from the top-level window
-    // close handler. Internally this calls CloseBrowser(false (0)) if the close
-    // has not yet been initiated. This function returns false (0) while the close
-    // is pending and true (1) after the close has completed. See close_browser()
-    // and cef_life_span_handler_t::do_close() documentation for additional usage
-    // information. This function must be called on the browser process UI thread.
-    ///
-    int function (_cef_browser_host_t* self) nothrow try_close_browser;
-
-    ///
-    // Set whether the browser is focused.
-    ///
-    void function (_cef_browser_host_t* self, int focus) nothrow set_focus;
-
-    ///
-    // Retrieve the window handle for this browser. If this browser is wrapped in
-    // a cef_browser_view_t this function should be called on the browser process
-    // UI thread and it will return the handle for the top-level native window.
-    ///
-    c_ulong function (_cef_browser_host_t* self) nothrow get_window_handle;
-
-    ///
-    // Retrieve the window handle of the browser that opened this browser. Will
-    // return NULL for non-popup windows or if this browser is wrapped in a
-    // cef_browser_view_t. This function can be used in combination with custom
-    // handling of modal windows.
-    ///
-    c_ulong function (_cef_browser_host_t* self) nothrow get_opener_window_handle;
-
-    ///
-    // Returns true (1) if this browser is wrapped in a cef_browser_view_t.
-    ///
-    int function (_cef_browser_host_t* self) nothrow has_view;
-
-    ///
-    // Returns the client for this browser.
-    ///
-    _cef_client_t* function (_cef_browser_host_t* self) nothrow get_client;
-
-    ///
-    // Returns the request context for this browser.
-    ///
-    _cef_request_context_t* function (
-        _cef_browser_host_t* self) nothrow get_request_context;
-
-    ///
-    // Get the current zoom level. The default zoom level is 0.0. This function
-    // can only be called on the UI thread.
-    ///
-    double function (_cef_browser_host_t* self) nothrow get_zoom_level;
-
-    ///
-    // Change the zoom level to the specified value. Specify 0.0 to reset the zoom
-    // level. If called on the UI thread the change will be applied immediately.
-    // Otherwise, the change will be applied asynchronously on the UI thread.
-    ///
-    void function (_cef_browser_host_t* self, double zoomLevel) nothrow set_zoom_level;
-
-    ///
-    // Call to run a file chooser dialog. Only a single file chooser dialog may be
-    // pending at any given time. |mode| represents the type of dialog to display.
-    // |title| to the title to be used for the dialog and may be NULL to show the
-    // default title ("Open" or "Save" depending on the mode). |default_file_path|
-    // is the path with optional directory and/or file name component that will be
-    // initially selected in the dialog. |accept_filters| are used to restrict the
-    // selectable file types and may any combination of (a) valid lower-cased MIME
-    // types (e.g. "text/*" or "image/*"), (b) individual file extensions (e.g.
-    // ".txt" or ".png"), or (c) combined description and file extension delimited
-    // using "|" and ";" (e.g. "Image Types|.png;.gif;.jpg").
-    // |selected_accept_filter| is the 0-based index of the filter that will be
-    // selected by default. |callback| will be executed after the dialog is
-    // dismissed or immediately if another dialog is already pending. The dialog
-    // will be initiated asynchronously on the UI thread.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        cef_file_dialog_mode_t mode,
-        const(cef_string_t)* title,
-        const(cef_string_t)* default_file_path,
-        cef_string_list_t accept_filters,
-        int selected_accept_filter,
-        _cef_run_file_dialog_callback_t* callback) nothrow run_file_dialog;
-
-    ///
-    // Download the file at |url| using cef_download_handler_t.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(cef_string_t)* url) nothrow start_download;
-
-    ///
-    // Download |image_url| and execute |callback| on completion with the images
-    // received from the renderer. If |is_favicon| is true (1) then cookies are
-    // not sent and not accepted during download. Images with density independent
-    // pixel (DIP) sizes larger than |max_image_size| are filtered out from the
-    // image results. Versions of the image at different scale factors may be
-    // downloaded up to the maximum scale factor supported by the system. If there
-    // are no image results <= |max_image_size| then the smallest image is resized
-    // to |max_image_size| and is the only result. A |max_image_size| of 0 means
-    // unlimited. If |bypass_cache| is true (1) then |image_url| is requested from
-    // the server even if it is present in the browser cache.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(cef_string_t)* image_url,
-        int is_favicon,
-        uint32 max_image_size,
-        int bypass_cache,
-        _cef_download_image_callback_t* callback) nothrow download_image;
-
-    ///
-    // Print the current browser contents.
-    ///
-    void function (_cef_browser_host_t* self) nothrow print;
-
-    ///
-    // Print the current browser contents to the PDF file specified by |path| and
-    // execute |callback| on completion. The caller is responsible for deleting
-    // |path| when done. For PDF printing to work on Linux you must implement the
-    // cef_print_handler_t::GetPdfPaperSize function.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(cef_string_t)* path,
-        const(_cef_pdf_print_settings_t)* settings,
-        _cef_pdf_print_callback_t* callback) nothrow print_to_pdf;
-
-    ///
-    // Search for |searchText|. |identifier| must be a unique ID and these IDs
-    // must strictly increase so that newer requests always have greater IDs than
-    // older requests. If |identifier| is zero or less than the previous ID value
-    // then it will be automatically assigned a new valid ID. |forward| indicates
-    // whether to search forward or backward within the page. |matchCase|
-    // indicates whether the search should be case-sensitive. |findNext| indicates
-    // whether this is the first request or a follow-up. The cef_find_handler_t
-    // instance, if any, returned via cef_client_t::GetFindHandler will be called
-    // to report find results.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        int identifier,
-        const(cef_string_t)* searchText,
-        int forward,
-        int matchCase,
-        int findNext) nothrow find;
-
-    ///
-    // Cancel all searches that are currently going on.
-    ///
-    void function (_cef_browser_host_t* self, int clearSelection) nothrow stop_finding;
-
-    ///
-    // Open developer tools (DevTools) in its own browser. The DevTools browser
-    // will remain associated with this browser. If the DevTools browser is
-    // already open then it will be focused, in which case the |windowInfo|,
-    // |client| and |settings| parameters will be ignored. If |inspect_element_at|
-    // is non-NULL then the element at the specified (x,y) location will be
-    // inspected. The |windowInfo| parameter will be ignored if this browser is
-    // wrapped in a cef_browser_view_t.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(_cef_window_info_t)* windowInfo,
-        _cef_client_t* client,
-        const(_cef_browser_settings_t)* settings,
-        const(cef_point_t)* inspect_element_at) nothrow show_dev_tools;
-
-    ///
-    // Explicitly close the associated DevTools browser, if any.
-    ///
-    void function (_cef_browser_host_t* self) nothrow close_dev_tools;
-
-    ///
-    // Returns true (1) if this browser currently has an associated DevTools
-    // browser. Must be called on the browser process UI thread.
-    ///
-    int function (_cef_browser_host_t* self) nothrow has_dev_tools;
-
-    ///
-    // Send a function call message over the DevTools protocol. |message| must be
-    // a UTF8-encoded JSON dictionary that contains "id" (int), "function"
-    // (string) and "params" (dictionary, optional) values. See the DevTools
-    // protocol documentation at https://chromedevtools.github.io/devtools-
-    // protocol/ for details of supported functions and the expected "params"
-    // dictionary contents. |message| will be copied if necessary. This function
-    // will return true (1) if called on the UI thread and the message was
-    // successfully submitted for validation, otherwise false (0). Validation will
-    // be applied asynchronously and any messages that fail due to formatting
-    // errors or missing parameters may be discarded without notification. Prefer
-    // ExecuteDevToolsMethod if a more structured approach to message formatting
-    // is desired.
-    //
-    // Every valid function call will result in an asynchronous function result or
-    // error message that references the sent message "id". Event messages are
-    // received while notifications are enabled (for example, between function
-    // calls for "Page.enable" and "Page.disable"). All received messages will be
-    // delivered to the observer(s) registered with AddDevToolsMessageObserver.
-    // See cef_dev_tools_message_observer_t::OnDevToolsMessage documentation for
-    // details of received message contents.
-    //
-    // Usage of the SendDevToolsMessage, ExecuteDevToolsMethod and
-    // AddDevToolsMessageObserver functions does not require an active DevTools
-    // front-end or remote-debugging session. Other active DevTools sessions will
-    // continue to function independently. However, any modification of global
-    // browser state by one session may not be reflected in the UI of other
-    // sessions.
-    //
-    // Communication with the DevTools front-end (when displayed) can be logged
-    // for development purposes by passing the `--devtools-protocol-log-
-    // file=<path>` command-line flag.
-    ///
-    int function (
-        _cef_browser_host_t* self,
-        const(void)* message,
-        size_t message_size) nothrow send_dev_tools_message;
-
-    ///
-    // Execute a function call over the DevTools protocol. This is a more
-    // structured version of SendDevToolsMessage. |message_id| is an incremental
-    // number that uniquely identifies the message (pass 0 to have the next number
-    // assigned automatically based on previous values). |function| is the
-    // function name. |params| are the function parameters, which may be NULL. See
-    // the DevTools protocol documentation (linked above) for details of supported
-    // functions and the expected |params| dictionary contents. This function will
-    // return the assigned message ID if called on the UI thread and the message
-    // was successfully submitted for validation, otherwise 0. See the
-    // SendDevToolsMessage documentation for additional usage information.
-    ///
-    int function (
-        _cef_browser_host_t* self,
-        int message_id,
-        const(cef_string_t)* method,
-        _cef_dictionary_value_t* params) nothrow execute_dev_tools_method;
-
-    ///
-    // Add an observer for DevTools protocol messages (function results and
-    // events). The observer will remain registered until the returned
-    // Registration object is destroyed. See the SendDevToolsMessage documentation
-    // for additional usage information.
-    ///
-    _cef_registration_t* function (
-        _cef_browser_host_t* self,
-        _cef_dev_tools_message_observer_t* observer) nothrow add_dev_tools_message_observer;
-
-    ///
-    // Retrieve a snapshot of current navigation entries as values sent to the
-    // specified visitor. If |current_only| is true (1) only the current
-    // navigation entry will be sent, otherwise all navigation entries will be
-    // sent.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        _cef_navigation_entry_visitor_t* visitor,
-        int current_only) nothrow get_navigation_entries;
-
-    ///
-    // If a misspelled word is currently selected in an editable node calling this
-    // function will replace it with the specified |word|.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(cef_string_t)* word) nothrow replace_misspelling;
-
-    ///
-    // Add the specified |word| to the spelling dictionary.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(cef_string_t)* word) nothrow add_word_to_dictionary;
-
-    ///
-    // Returns true (1) if window rendering is disabled.
-    ///
-    int function (_cef_browser_host_t* self) nothrow is_window_rendering_disabled;
-
-    ///
-    // Notify the browser that the widget has been resized. The browser will first
-    // call cef_render_handler_t::GetViewRect to get the new size and then call
-    // cef_render_handler_t::OnPaint asynchronously with the updated regions. This
-    // function is only used when window rendering is disabled.
-    ///
-    void function (_cef_browser_host_t* self) nothrow was_resized;
-
-    ///
-    // Notify the browser that it has been hidden or shown. Layouting and
-    // cef_render_handler_t::OnPaint notification will stop when the browser is
-    // hidden. This function is only used when window rendering is disabled.
-    ///
-    void function (_cef_browser_host_t* self, int hidden) nothrow was_hidden;
-
-    ///
-    // Send a notification to the browser that the screen info has changed. The
-    // browser will then call cef_render_handler_t::GetScreenInfo to update the
-    // screen information with the new values. This simulates moving the webview
-    // window from one display to another, or changing the properties of the
-    // current display. This function is only used when window rendering is
-    // disabled.
-    ///
-    void function (_cef_browser_host_t* self) nothrow notify_screen_info_changed;
-
-    ///
-    // Invalidate the view. The browser will call cef_render_handler_t::OnPaint
-    // asynchronously. This function is only used when window rendering is
-    // disabled.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        cef_paint_element_type_t type) nothrow invalidate;
-
-    ///
-    // Issue a BeginFrame request to Chromium.  Only valid when
-    // cef_window_tInfo::external_begin_frame_enabled is set to true (1).
-    ///
-    void function (_cef_browser_host_t* self) nothrow send_external_begin_frame;
-
-    ///
-    // Send a key event to the browser.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(_cef_key_event_t)* event) nothrow send_key_event;
-
-    ///
-    // Send a mouse click event to the browser. The |x| and |y| coordinates are
-    // relative to the upper-left corner of the view.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(_cef_mouse_event_t)* event,
-        cef_mouse_button_type_t type,
-        int mouseUp,
-        int clickCount) nothrow send_mouse_click_event;
-
-    ///
-    // Send a mouse move event to the browser. The |x| and |y| coordinates are
-    // relative to the upper-left corner of the view.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(_cef_mouse_event_t)* event,
-        int mouseLeave) nothrow send_mouse_move_event;
-
-    ///
-    // Send a mouse wheel event to the browser. The |x| and |y| coordinates are
-    // relative to the upper-left corner of the view. The |deltaX| and |deltaY|
-    // values represent the movement delta in the X and Y directions respectively.
-    // In order to scroll inside select popups with window rendering disabled
-    // cef_render_handler_t::GetScreenPoint should be implemented properly.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(_cef_mouse_event_t)* event,
-        int deltaX,
-        int deltaY) nothrow send_mouse_wheel_event;
-
-    ///
-    // Send a touch event to the browser for a windowless browser.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(_cef_touch_event_t)* event) nothrow send_touch_event;
-
-    ///
-    // Send a focus event to the browser.
-    ///
-    void function (_cef_browser_host_t* self, int setFocus) nothrow send_focus_event;
-
-    ///
-    // Send a capture lost event to the browser.
-    ///
-    void function (_cef_browser_host_t* self) nothrow send_capture_lost_event;
-
-    ///
-    // Notify the browser that the window hosting it is about to be moved or
-    // resized. This function is only used on Windows and Linux.
-    ///
-    void function (_cef_browser_host_t* self) nothrow notify_move_or_resize_started;
-
-    ///
-    // Returns the maximum rate in frames per second (fps) that
-    // cef_render_handler_t:: OnPaint will be called for a windowless browser. The
-    // actual fps may be lower if the browser cannot generate frames at the
-    // requested rate. The minimum value is 1 and the maximum value is 60 (default
-    // 30). This function can only be called on the UI thread.
-    ///
-    int function (_cef_browser_host_t* self) nothrow get_windowless_frame_rate;
-
-    ///
-    // Set the maximum rate in frames per second (fps) that cef_render_handler_t::
-    // OnPaint will be called for a windowless browser. The actual fps may be
-    // lower if the browser cannot generate frames at the requested rate. The
-    // minimum value is 1 and the maximum value is 60 (default 30). Can also be
-    // set at browser creation via cef_browser_tSettings.windowless_frame_rate.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        int frame_rate) nothrow set_windowless_frame_rate;
-
-    ///
-    // Begins a new composition or updates the existing composition. Blink has a
-    // special node (a composition node) that allows the input function to change
-    // text without affecting other DOM nodes. |text| is the optional text that
-    // will be inserted into the composition node. |underlines| is an optional set
-    // of ranges that will be underlined in the resulting text.
-    // |replacement_range| is an optional range of the existing text that will be
-    // replaced. |selection_range| is an optional range of the resulting text that
-    // will be selected after insertion or replacement. The |replacement_range|
-    // value is only used on OS X.
-    //
-    // This function may be called multiple times as the composition changes. When
-    // the client is done making changes the composition should either be canceled
-    // or completed. To cancel the composition call ImeCancelComposition. To
-    // complete the composition call either ImeCommitText or
-    // ImeFinishComposingText. Completion is usually signaled when:
-    //   A. The client receives a WM_IME_COMPOSITION message with a GCS_RESULTSTR
-    //      flag (on Windows), or;
-    //   B. The client receives a "commit" signal of GtkIMContext (on Linux), or;
-    //   C. insertText of NSTextInput is called (on Mac).
-    //
-    // This function is only used when window rendering is disabled.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(cef_string_t)* text,
-        size_t underlinesCount,
-        const(cef_composition_underline_t)* underlines,
-        const(cef_range_t)* replacement_range,
-        const(cef_range_t)* selection_range) nothrow ime_set_composition;
-
-    ///
-    // Completes the existing composition by optionally inserting the specified
-    // |text| into the composition node. |replacement_range| is an optional range
-    // of the existing text that will be replaced. |relative_cursor_pos| is where
-    // the cursor will be positioned relative to the current cursor position. See
-    // comments on ImeSetComposition for usage. The |replacement_range| and
-    // |relative_cursor_pos| values are only used on OS X. This function is only
-    // used when window rendering is disabled.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(cef_string_t)* text,
-        const(cef_range_t)* replacement_range,
-        int relative_cursor_pos) nothrow ime_commit_text;
-
-    ///
-    // Completes the existing composition by applying the current composition node
-    // contents. If |keep_selection| is false (0) the current selection, if any,
-    // will be discarded. See comments on ImeSetComposition for usage. This
-    // function is only used when window rendering is disabled.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        int keep_selection) nothrow ime_finish_composing_text;
-
-    ///
-    // Cancels the existing composition and discards the composition node contents
-    // without applying them. See comments on ImeSetComposition for usage. This
-    // function is only used when window rendering is disabled.
-    ///
-    void function (_cef_browser_host_t* self) nothrow ime_cancel_composition;
-
-    ///
-    // Call this function when the user drags the mouse into the web view (before
-    // calling DragTargetDragOver/DragTargetLeave/DragTargetDrop). |drag_data|
-    // should not contain file contents as this type of data is not allowed to be
-    // dragged into the web view. File contents can be removed using
-    // cef_drag_data_t::ResetFileContents (for example, if |drag_data| comes from
-    // cef_render_handler_t::StartDragging). This function is only used when
-    // window rendering is disabled.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        _cef_drag_data_t* drag_data,
-        const(_cef_mouse_event_t)* event,
-        cef_drag_operations_mask_t allowed_ops) nothrow drag_target_drag_enter;
-
-    ///
-    // Call this function each time the mouse is moved across the web view during
-    // a drag operation (after calling DragTargetDragEnter and before calling
-    // DragTargetDragLeave/DragTargetDrop). This function is only used when window
-    // rendering is disabled.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(_cef_mouse_event_t)* event,
-        cef_drag_operations_mask_t allowed_ops) nothrow drag_target_drag_over;
-
-    ///
-    // Call this function when the user drags the mouse out of the web view (after
-    // calling DragTargetDragEnter). This function is only used when window
-    // rendering is disabled.
-    ///
-    void function (_cef_browser_host_t* self) nothrow drag_target_drag_leave;
-
-    ///
-    // Call this function when the user completes the drag operation by dropping
-    // the object onto the web view (after calling DragTargetDragEnter). The
-    // object being dropped is |drag_data|, given as an argument to the previous
-    // DragTargetDragEnter call. This function is only used when window rendering
-    // is disabled.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        const(_cef_mouse_event_t)* event) nothrow drag_target_drop;
-
-    ///
-    // Call this function when the drag operation started by a
-    // cef_render_handler_t::StartDragging call has ended either in a drop or by
-    // being cancelled. |x| and |y| are mouse coordinates relative to the upper-
-    // left corner of the view. If the web view is both the drag source and the
-    // drag target then all DragTarget* functions should be called before
-    // DragSource* mthods. This function is only used when window rendering is
-    // disabled.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        int x,
-        int y,
-        cef_drag_operations_mask_t op) nothrow drag_source_ended_at;
-
-    ///
-    // Call this function when the drag operation started by a
-    // cef_render_handler_t::StartDragging call has completed. This function may
-    // be called immediately without first calling DragSourceEndedAt to cancel a
-    // drag operation. If the web view is both the drag source and the drag target
-    // then all DragTarget* functions should be called before DragSource* mthods.
-    // This function is only used when window rendering is disabled.
-    ///
-    void function (_cef_browser_host_t* self) nothrow drag_source_system_drag_ended;
-
-    ///
-    // Returns the current visible navigation entry for this browser. This
-    // function can only be called on the UI thread.
-    ///
-    _cef_navigation_entry_t* function (
-        _cef_browser_host_t* self) nothrow get_visible_navigation_entry;
-
-    ///
-    // Set accessibility state for all frames. |accessibility_state| may be
-    // default, enabled or disabled. If |accessibility_state| is STATE_DEFAULT
-    // then accessibility will be disabled by default and the state may be further
-    // controlled with the "force-renderer-accessibility" and "disable-renderer-
-    // accessibility" command-line switches. If |accessibility_state| is
-    // STATE_ENABLED then accessibility will be enabled. If |accessibility_state|
-    // is STATE_DISABLED then accessibility will be completely disabled.
-    //
-    // For windowed browsers accessibility will be enabled in Complete mode (which
-    // corresponds to kAccessibilityModeComplete in Chromium). In this mode all
-    // platform accessibility objects will be created and managed by Chromium's
-    // internal implementation. The client needs only to detect the screen reader
-    // and call this function appropriately. For example, on macOS the client can
-    // handle the @"AXEnhancedUserStructure" accessibility attribute to detect
-    // VoiceOver state changes and on Windows the client can handle WM_GETOBJECT
-    // with OBJID_CLIENT to detect accessibility readers.
-    //
-    // For windowless browsers accessibility will be enabled in TreeOnly mode
-    // (which corresponds to kAccessibilityModeWebContentsOnly in Chromium). In
-    // this mode renderer accessibility is enabled, the full tree is computed, and
-    // events are passed to CefAccessibiltyHandler, but platform accessibility
-    // objects are not created. The client may implement platform accessibility
-    // objects using CefAccessibiltyHandler callbacks if desired.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        cef_state_t accessibility_state) nothrow set_accessibility_state;
-
-    ///
-    // Enable notifications of auto resize via
-    // cef_display_handler_t::OnAutoResize. Notifications are disabled by default.
-    // |min_size| and |max_size| define the range of allowed sizes.
-    ///
-    void function (
-        _cef_browser_host_t* self,
-        int enabled,
-        const(cef_size_t)* min_size,
-        const(cef_size_t)* max_size) nothrow set_auto_resize_enabled;
-
-    ///
-    // Returns the extension hosted in this browser or NULL if no extension is
-    // hosted. See cef_request_context_t::LoadExtension for details.
-    ///
-    _cef_extension_t* function (_cef_browser_host_t* self) nothrow get_extension;
-
-    ///
-    // Returns true (1) if this browser is hosting an extension background script.
-    // Background hosts do not have a window and are not displayable. See
-    // cef_request_context_t::LoadExtension for details.
-    ///
-    int function (_cef_browser_host_t* self) nothrow is_background_host;
-
-    ///
-    //  Set whether the browser's audio is muted.
-    ///
-    void function (_cef_browser_host_t* self, int mute) nothrow set_audio_muted;
-
-    ///
-    // Returns true (1) if the browser's audio is muted.  This function can only
-    // be called on the UI thread.
-    ///
-    int function (_cef_browser_host_t* self) nothrow is_audio_muted;
-}
-
-alias cef_browser_host_t = _cef_browser_host_t;
-
-///
-// Create a new browser window using the window parameters specified by
-// |windowInfo|. All values will be copied internally and the actual window will
-// be created on the UI thread. If |request_context| is NULL the global request
-// context will be used. This function can be called on any browser process
-// thread and will not block. The optional |extra_info| parameter provides an
-// opportunity to specify extra information specific to the created browser that
-// will be passed to cef_render_process_handler_t::on_browser_created() in the
-// render process.
-///
-int cef_browser_host_create_browser (
-    const(cef_window_info_t)* windowInfo,
-    _cef_client_t* client,
-    const(cef_string_t)* url,
-    const(_cef_browser_settings_t)* settings,
-    _cef_dictionary_value_t* extra_info,
-    _cef_request_context_t* request_context);
-
-///
-// Create a new browser window using the window parameters specified by
-// |windowInfo|. If |request_context| is NULL the global request context will be
-// used. This function can only be called on the browser process UI thread. The
-// optional |extra_info| parameter provides an opportunity to specify extra
-// information specific to the created browser that will be passed to
-// cef_render_process_handler_t::on_browser_created() in the render process.
-///
-cef_browser_t* cef_browser_host_create_browser_sync (
-    const(cef_window_info_t)* windowInfo,
-    _cef_client_t* client,
-    const(cef_string_t)* url,
-    const(_cef_browser_settings_t)* settings,
-    _cef_dictionary_value_t* extra_info,
-    _cef_request_context_t* request_context);
-
-// CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=d56cbf83d6faefa9f716c7308bf7007dad98697d$
-//
-
-extern (C):
-
-///
-// Structure used to implement browser process callbacks. The functions of this
-// structure will be called on the browser process main thread unless otherwise
-// indicated.
-///
-struct _cef_browser_process_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called on the browser process UI thread to retrieve the list of schemes
-    // that should support cookies. If |include_defaults| is true (1) the default
-    // schemes ("http", "https", "ws" and "wss") will also be supported. Providing
-    // an NULL |schemes| value and setting |include_defaults| to false (0) will
-    // disable all loading and saving of cookies.
-    //
-    // This state will apply to the cef_cookie_manager_t associated with the
-    // global cef_request_context_t. It will also be used as the initial state for
-    // any new cef_request_context_ts created by the client. After creating a new
-    // cef_request_context_t the cef_cookie_manager_t::SetSupportedSchemes
-    // function may be called on the associated cef_cookie_manager_t to futher
-    // override these values.
-    ///
-    void function (
-        _cef_browser_process_handler_t* self,
-        cef_string_list_t schemes,
-        int* include_defaults) nothrow get_cookieable_schemes;
-
-    ///
-    // Called on the browser process UI thread immediately after the CEF context
-    // has been initialized.
-    ///
-    void function (
-        _cef_browser_process_handler_t* self) nothrow on_context_initialized;
-
-    ///
-    // Called before a child process is launched. Will be called on the browser
-    // process UI thread when launching a render process and on the browser
-    // process IO thread when launching a GPU or plugin process. Provides an
-    // opportunity to modify the child process command line. Do not keep a
-    // reference to |command_line| outside of this function.
-    ///
-    void function (
-        _cef_browser_process_handler_t* self,
-        _cef_command_line_t* command_line) nothrow on_before_child_process_launch;
-
-    ///
-    // Return the handler for printing on Linux. If a print handler is not
-    // provided then printing will not be supported on the Linux platform.
-    ///
-    _cef_print_handler_t* function (
-        _cef_browser_process_handler_t* self) nothrow get_print_handler;
-
-    ///
-    // Called from any thread when work has been scheduled for the browser process
-    // main (UI) thread. This callback is used in combination with CefSettings.
-    // external_message_pump and cef_do_message_loop_work() in cases where the CEF
-    // message loop must be integrated into an existing application message loop
-    // (see additional comments and warnings on CefDoMessageLoopWork). This
-    // callback should schedule a cef_do_message_loop_work() call to happen on the
-    // main (UI) thread. |delay_ms| is the requested delay in milliseconds. If
-    // |delay_ms| is <= 0 then the call should happen reasonably soon. If
-    // |delay_ms| is > 0 then the call should be scheduled to happen after the
-    // specified delay and any currently pending scheduled call should be
-    // cancelled.
-    ///
-    void function (
-        _cef_browser_process_handler_t* self,
-        int64 delay_ms) nothrow on_schedule_message_pump_work;
-
-    ///
-    // Return the default client for use with a newly created browser window. If
-    // null is returned the browser will be unmanaged (no callbacks will be
-    // executed for that browser) and application shutdown will be blocked until
-    // the browser window is closed manually. This function is currently only used
-    // with the chrome runtime.
-    ///
-    _cef_client_t* function (
-        _cef_browser_process_handler_t* self) nothrow get_default_client;
-}
-
-alias cef_browser_process_handler_t = _cef_browser_process_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=5c540e617cf2782876defad365e85cd43932ffce$
-//
-
-extern (C):
-
-///
-// Generic callback structure used for asynchronous continuation.
-///
-struct _cef_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Continue processing.
-    ///
-    void function (_cef_callback_t* self) nothrow cont;
-
-    ///
-    // Cancel processing.
-    ///
-    void function (_cef_callback_t* self) nothrow cancel;
-}
-
-alias cef_callback_t = _cef_callback_t;
-
-///
-// Generic callback structure used for asynchronous completion.
-///
-struct _cef_completion_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be called once the task is complete.
-    ///
-    void function (_cef_completion_callback_t* self) nothrow on_complete;
-}
-
-alias cef_completion_callback_t = _cef_completion_callback_t;
-
-// CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=8d4cb3e0bbf230804c93898daa4a8b2866a2c1ce$
-//
-
-extern (C):
-
-///
-// Implement this structure to provide handler implementations.
-///
-struct _cef_client_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Return the handler for audio rendering events.
-    ///
-    _cef_audio_handler_t* function (_cef_client_t* self) nothrow get_audio_handler;
-
-    ///
-    // Return the handler for context menus. If no handler is provided the default
-    // implementation will be used.
-    ///
-    _cef_context_menu_handler_t* function (
-        _cef_client_t* self) nothrow get_context_menu_handler;
-
-    ///
-    // Return the handler for dialogs. If no handler is provided the default
-    // implementation will be used.
-    ///
-    _cef_dialog_handler_t* function (_cef_client_t* self) nothrow get_dialog_handler;
-
-    ///
-    // Return the handler for browser display state events.
-    ///
-    _cef_display_handler_t* function (_cef_client_t* self) nothrow get_display_handler;
-
-    ///
-    // Return the handler for download events. If no handler is returned downloads
-    // will not be allowed.
-    ///
-    _cef_download_handler_t* function (
-        _cef_client_t* self) nothrow get_download_handler;
-
-    ///
-    // Return the handler for drag events.
-    ///
-    _cef_drag_handler_t* function (_cef_client_t* self) nothrow get_drag_handler;
-
-    ///
-    // Return the handler for find result events.
-    ///
-    _cef_find_handler_t* function (_cef_client_t* self) nothrow get_find_handler;
-
-    ///
-    // Return the handler for focus events.
-    ///
-    _cef_focus_handler_t* function (_cef_client_t* self) nothrow get_focus_handler;
-
-    ///
-    // Return the handler for JavaScript dialogs. If no handler is provided the
-    // default implementation will be used.
-    ///
-    _cef_jsdialog_handler_t* function (
-        _cef_client_t* self) nothrow get_jsdialog_handler;
-
-    ///
-    // Return the handler for keyboard events.
-    ///
-    _cef_keyboard_handler_t* function (
-        _cef_client_t* self) nothrow get_keyboard_handler;
-
-    ///
-    // Return the handler for browser life span events.
-    ///
-    _cef_life_span_handler_t* function (
-        _cef_client_t* self) nothrow get_life_span_handler;
-
-    ///
-    // Return the handler for browser load status events.
-    ///
-    _cef_load_handler_t* function (_cef_client_t* self) nothrow get_load_handler;
-
-    ///
-    // Return the handler for off-screen rendering events.
-    ///
-    _cef_render_handler_t* function (_cef_client_t* self) nothrow get_render_handler;
-
-    ///
-    // Return the handler for browser request events.
-    ///
-    _cef_request_handler_t* function (_cef_client_t* self) nothrow get_request_handler;
-
-    ///
-    // Called when a new message is received from a different process. Return true
-    // (1) if the message was handled or false (0) otherwise. Do not keep a
-    // reference to or attempt to access the message outside of this callback.
-    ///
-    int function (
-        _cef_client_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        cef_process_id_t source_process,
-        _cef_process_message_t* message) nothrow on_process_message_received;
-}
-
-alias cef_client_t = _cef_client_t;
-
-// CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=72ba5fe0cc6fe8081ec7b2b556e9022d1c6e8c61$
-//
-
-extern (C):
-
-///
-// Structure used to create and/or parse command line arguments. Arguments with
-// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
-// will always precede any arguments without switch prefixes. Switches can
-// optionally have a value specified using the '=' delimiter (e.g.
-// "-switch=value"). An argument of "--" will terminate switch parsing with all
-// subsequent tokens, regardless of prefix, being interpreted as non-switch
-// arguments. Switch names are considered case-insensitive. This structure can
-// be used before cef_initialize() is called.
-///
-struct _cef_command_line_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is valid. Do not call any other functions
-    // if this function returns false (0).
-    ///
-    int function (_cef_command_line_t* self) nothrow is_valid;
-
-    ///
-    // Returns true (1) if the values of this object are read-only. Some APIs may
-    // expose read-only objects.
-    ///
-    int function (_cef_command_line_t* self) nothrow is_read_only;
-
-    ///
-    // Returns a writable copy of this object.
-    ///
-    _cef_command_line_t* function (_cef_command_line_t* self) nothrow copy;
-
-    ///
-    // Initialize the command line with the specified |argc| and |argv| values.
-    // The first argument must be the name of the program. This function is only
-    // supported on non-Windows platforms.
-    ///
-    void function (
-        _cef_command_line_t* self,
-        int argc,
-        const(char*)* argv) nothrow init_from_argv;
-
-    ///
-    // Initialize the command line with the string returned by calling
-    // GetCommandLineW(). This function is only supported on Windows.
-    ///
-    void function (
-        _cef_command_line_t* self,
-        const(cef_string_t)* command_line) nothrow init_from_string;
-
-    ///
-    // Reset the command-line switches and arguments but leave the program
-    // component unchanged.
-    ///
-    void function (_cef_command_line_t* self) nothrow reset;
-
-    ///
-    // Retrieve the original command line string as a vector of strings. The argv
-    // array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
-    ///
-    void function (_cef_command_line_t* self, cef_string_list_t argv) nothrow get_argv;
-
-    ///
-    // Constructs and returns the represented command line string. Use this
-    // function cautiously because quoting behavior is unclear.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_command_line_t* self) nothrow get_command_line_string;
-
-    ///
-    // Get the program part of the command line string (the first item).
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_command_line_t* self) nothrow get_program;
-
-    ///
-    // Set the program part of the command line string (the first item).
-    ///
-    void function (
-        _cef_command_line_t* self,
-        const(cef_string_t)* program) nothrow set_program;
-
-    ///
-    // Returns true (1) if the command line has switches.
-    ///
-    int function (_cef_command_line_t* self) nothrow has_switches;
-
-    ///
-    // Returns true (1) if the command line contains the given switch.
-    ///
-    int function (
-        _cef_command_line_t* self,
-        const(cef_string_t)* name) nothrow has_switch;
-
-    ///
-    // Returns the value associated with the given switch. If the switch has no
-    // value or isn't present this function returns the NULL string.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_command_line_t* self,
-        const(cef_string_t)* name) nothrow get_switch_value;
-
-    ///
-    // Returns the map of switch names and values. If a switch has no value an
-    // NULL string is returned.
-    ///
-    void function (
-        _cef_command_line_t* self,
-        cef_string_map_t switches) nothrow get_switches;
-
-    ///
-    // Add a switch to the end of the command line. If the switch has no value
-    // pass an NULL value string.
-    ///
-    void function (
-        _cef_command_line_t* self,
-        const(cef_string_t)* name) nothrow append_switch;
-
-    ///
-    // Add a switch with the specified value to the end of the command line.
-    ///
-    void function (
-        _cef_command_line_t* self,
-        const(cef_string_t)* name,
-        const(cef_string_t)* value) nothrow append_switch_with_value;
-
-    ///
-    // True if there are remaining command line arguments.
-    ///
-    int function (_cef_command_line_t* self) nothrow has_arguments;
-
-    ///
-    // Get the remaining command line arguments.
-    ///
-    void function (
-        _cef_command_line_t* self,
-        cef_string_list_t arguments) nothrow get_arguments;
-
-    ///
-    // Add an argument to the end of the command line.
-    ///
-    void function (
-        _cef_command_line_t* self,
-        const(cef_string_t)* argument) nothrow append_argument;
-
-    ///
-    // Insert a command before the current command. Common for debuggers, like
-    // "valgrind" or "gdb --args".
-    ///
-    void function (
-        _cef_command_line_t* self,
-        const(cef_string_t)* wrapper) nothrow prepend_wrapper;
-}
-
-alias cef_command_line_t = _cef_command_line_t;
-
-///
-// Create a new cef_command_line_t instance.
-///
-cef_command_line_t* cef_command_line_create ();
-
-///
-// Returns the singleton global cef_command_line_t object. The returned object
-// will be read-only.
-///
-cef_command_line_t* cef_command_line_get_global ();
-
-// CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=fcb0328c54e5f629c24bfd232d75c31c372ab6ac$
-//
-
-extern (C):
-
-///
-// Callback structure used for continuation of custom context menu display.
-///
-struct _cef_run_context_menu_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Complete context menu display by selecting the specified |command_id| and
-    // |event_flags|.
-    ///
-    void function (
-        _cef_run_context_menu_callback_t* self,
-        int command_id,
-        cef_event_flags_t event_flags) nothrow cont;
-
-    ///
-    // Cancel context menu display.
-    ///
-    void function (_cef_run_context_menu_callback_t* self) nothrow cancel;
-}
-
-alias cef_run_context_menu_callback_t = _cef_run_context_menu_callback_t;
-
-///
-// Implement this structure to handle context menu events. The functions of this
-// structure will be called on the UI thread.
-///
-struct _cef_context_menu_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called before a context menu is displayed. |params| provides information
-    // about the context menu state. |model| initially contains the default
-    // context menu. The |model| can be cleared to show no context menu or
-    // modified to show a custom menu. Do not keep references to |params| or
-    // |model| outside of this callback.
-    ///
-    void function (
-        _cef_context_menu_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_context_menu_params_t* params,
-        _cef_menu_model_t* model) nothrow on_before_context_menu;
-
-    ///
-    // Called to allow custom display of the context menu. |params| provides
-    // information about the context menu state. |model| contains the context menu
-    // model resulting from OnBeforeContextMenu. For custom display return true
-    // (1) and execute |callback| either synchronously or asynchronously with the
-    // selected command ID. For default display return false (0). Do not keep
-    // references to |params| or |model| outside of this callback.
-    ///
-    int function (
-        _cef_context_menu_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_context_menu_params_t* params,
-        _cef_menu_model_t* model,
-        _cef_run_context_menu_callback_t* callback) nothrow run_context_menu;
-
-    ///
-    // Called to execute a command selected from the context menu. Return true (1)
-    // if the command was handled or false (0) for the default implementation. See
-    // cef_menu_id_t for the command ids that have default implementations. All
-    // user-defined command ids should be between MENU_ID_USER_FIRST and
-    // MENU_ID_USER_LAST. |params| will have the same values as what was passed to
-    // on_before_context_menu(). Do not keep a reference to |params| outside of
-    // this callback.
-    ///
-    int function (
-        _cef_context_menu_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_context_menu_params_t* params,
-        int command_id,
-        cef_event_flags_t event_flags) nothrow on_context_menu_command;
-
-    ///
-    // Called when the context menu is dismissed irregardless of whether the menu
-    // was NULL or a command was selected.
-    ///
-    void function (
-        _cef_context_menu_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame) nothrow on_context_menu_dismissed;
-}
-
-alias cef_context_menu_handler_t = _cef_context_menu_handler_t;
-
-///
-// Provides information about the context menu state. The ethods of this
-// structure can only be accessed on browser process the UI thread.
-///
-struct _cef_context_menu_params_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the X coordinate of the mouse where the context menu was invoked.
-    // Coords are relative to the associated RenderView's origin.
-    ///
-    int function (_cef_context_menu_params_t* self) nothrow get_xcoord;
-
-    ///
-    // Returns the Y coordinate of the mouse where the context menu was invoked.
-    // Coords are relative to the associated RenderView's origin.
-    ///
-    int function (_cef_context_menu_params_t* self) nothrow get_ycoord;
-
-    ///
-    // Returns flags representing the type of node that the context menu was
-    // invoked on.
-    ///
-    cef_context_menu_type_flags_t function (
-        _cef_context_menu_params_t* self) nothrow get_type_flags;
-
-    ///
-    // Returns the URL of the link, if any, that encloses the node that the
-    // context menu was invoked on.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_context_menu_params_t* self) nothrow get_link_url;
-
-    ///
-    // Returns the link URL, if any, to be used ONLY for "copy link address". We
-    // don't validate this field in the frontend process.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_context_menu_params_t* self) nothrow get_unfiltered_link_url;
-
-    ///
-    // Returns the source URL, if any, for the element that the context menu was
-    // invoked on. Example of elements with source URLs are img, audio, and video.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_context_menu_params_t* self) nothrow get_source_url;
-
-    ///
-    // Returns true (1) if the context menu was invoked on an image which has non-
-    // NULL contents.
-    ///
-    int function (_cef_context_menu_params_t* self) nothrow has_image_contents;
-
-    ///
-    // Returns the title text or the alt text if the context menu was invoked on
-    // an image.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_context_menu_params_t* self) nothrow get_title_text;
-
-    ///
-    // Returns the URL of the top level page that the context menu was invoked on.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_context_menu_params_t* self) nothrow get_page_url;
-
-    ///
-    // Returns the URL of the subframe that the context menu was invoked on.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_context_menu_params_t* self) nothrow get_frame_url;
-
-    ///
-    // Returns the character encoding of the subframe that the context menu was
-    // invoked on.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_context_menu_params_t* self) nothrow get_frame_charset;
-
-    ///
-    // Returns the type of context node that the context menu was invoked on.
-    ///
-    cef_context_menu_media_type_t function (
-        _cef_context_menu_params_t* self) nothrow get_media_type;
-
-    ///
-    // Returns flags representing the actions supported by the media element, if
-    // any, that the context menu was invoked on.
-    ///
-    cef_context_menu_media_state_flags_t function (
-        _cef_context_menu_params_t* self) nothrow get_media_state_flags;
-
-    ///
-    // Returns the text of the selection, if any, that the context menu was
-    // invoked on.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_context_menu_params_t* self) nothrow get_selection_text;
-
-    ///
-    // Returns the text of the misspelled word, if any, that the context menu was
-    // invoked on.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_context_menu_params_t* self) nothrow get_misspelled_word;
-
-    ///
-    // Returns true (1) if suggestions exist, false (0) otherwise. Fills in
-    // |suggestions| from the spell check service for the misspelled word if there
-    // is one.
-    ///
-    int function (
-        _cef_context_menu_params_t* self,
-        cef_string_list_t suggestions) nothrow get_dictionary_suggestions;
-
-    ///
-    // Returns true (1) if the context menu was invoked on an editable node.
-    ///
-    int function (_cef_context_menu_params_t* self) nothrow is_editable;
-
-    ///
-    // Returns true (1) if the context menu was invoked on an editable node where
-    // spell-check is enabled.
-    ///
-    int function (_cef_context_menu_params_t* self) nothrow is_spell_check_enabled;
-
-    ///
-    // Returns flags representing the actions supported by the editable node, if
-    // any, that the context menu was invoked on.
-    ///
-    cef_context_menu_edit_state_flags_t function (
-        _cef_context_menu_params_t* self) nothrow get_edit_state_flags;
-
-    ///
-    // Returns true (1) if the context menu contains items specified by the
-    // renderer process (for example, plugin placeholder or pepper plugin menu
-    // items).
-    ///
-    int function (_cef_context_menu_params_t* self) nothrow is_custom_menu;
-
-    ///
-    // Returns true (1) if the context menu was invoked from a pepper plugin.
-    ///
-    int function (_cef_context_menu_params_t* self) nothrow is_pepper_menu;
-}
-
-alias cef_context_menu_params_t = _cef_context_menu_params_t;
-
-// CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=2f5721138da26a9d7cce300a635b58dae9f51a4a$
-//
-
-extern (C):
-
-///
-// Structure used for managing cookies. The functions of this structure may be
-// called on any thread unless otherwise indicated.
-///
-struct _cef_cookie_manager_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Set the schemes supported by this manager. If |include_defaults| is true
-    // (1) the default schemes ("http", "https", "ws" and "wss") will also be
-    // supported. Calling this function with an NULL |schemes| value and
-    // |include_defaults| set to false (0) will disable all loading and saving of
-    // cookies for this manager. If |callback| is non-NULL it will be executed
-    // asnychronously on the UI thread after the change has been applied. Must be
-    // called before any cookies are accessed.
-    ///
-    void function (
-        _cef_cookie_manager_t* self,
-        cef_string_list_t schemes,
-        int include_defaults,
-        _cef_completion_callback_t* callback) nothrow set_supported_schemes;
-
-    ///
-    // Visit all cookies on the UI thread. The returned cookies are ordered by
-    // longest path, then by earliest creation date. Returns false (0) if cookies
-    // cannot be accessed.
-    ///
-    int function (
-        _cef_cookie_manager_t* self,
-        _cef_cookie_visitor_t* visitor) nothrow visit_all_cookies;
-
-    ///
-    // Visit a subset of cookies on the UI thread. The results are filtered by the
-    // given url scheme, host, domain and path. If |includeHttpOnly| is true (1)
-    // HTTP-only cookies will also be included in the results. The returned
-    // cookies are ordered by longest path, then by earliest creation date.
-    // Returns false (0) if cookies cannot be accessed.
-    ///
-    int function (
-        _cef_cookie_manager_t* self,
-        const(cef_string_t)* url,
-        int includeHttpOnly,
-        _cef_cookie_visitor_t* visitor) nothrow visit_url_cookies;
-
-    ///
-    // Sets a cookie given a valid URL and explicit user-provided cookie
-    // attributes. This function expects each attribute to be well-formed. It will
-    // check for disallowed characters (e.g. the ';' character is disallowed
-    // within the cookie value attribute) and fail without setting the cookie if
-    // such characters are found. If |callback| is non-NULL it will be executed
-    // asnychronously on the UI thread after the cookie has been set. Returns
-    // false (0) if an invalid URL is specified or if cookies cannot be accessed.
-    ///
-    int function (
-        _cef_cookie_manager_t* self,
-        const(cef_string_t)* url,
-        const(_cef_cookie_t)* cookie,
-        _cef_set_cookie_callback_t* callback) nothrow set_cookie;
-
-    ///
-    // Delete all cookies that match the specified parameters. If both |url| and
-    // |cookie_name| values are specified all host and domain cookies matching
-    // both will be deleted. If only |url| is specified all host cookies (but not
-    // domain cookies) irrespective of path will be deleted. If |url| is NULL all
-    // cookies for all hosts and domains will be deleted. If |callback| is non-
-    // NULL it will be executed asnychronously on the UI thread after the cookies
-    // have been deleted. Returns false (0) if a non-NULL invalid URL is specified
-    // or if cookies cannot be accessed. Cookies can alternately be deleted using
-    // the Visit*Cookies() functions.
-    ///
-    int function (
-        _cef_cookie_manager_t* self,
-        const(cef_string_t)* url,
-        const(cef_string_t)* cookie_name,
-        _cef_delete_cookies_callback_t* callback) nothrow delete_cookies;
-
-    ///
-    // Flush the backing store (if any) to disk. If |callback| is non-NULL it will
-    // be executed asnychronously on the UI thread after the flush is complete.
-    // Returns false (0) if cookies cannot be accessed.
-    ///
-    int function (
-        _cef_cookie_manager_t* self,
-        _cef_completion_callback_t* callback) nothrow flush_store;
-}
-
-alias cef_cookie_manager_t = _cef_cookie_manager_t;
-
-///
-// Returns the global cookie manager. By default data will be stored at
-// CefSettings.cache_path if specified or in memory otherwise. If |callback| is
-// non-NULL it will be executed asnychronously on the UI thread after the
-// manager's storage has been initialized. Using this function is equivalent to
-// calling cef_request_context_t::cef_request_context_get_global_context()->GetD
-// efaultCookieManager().
-///
-cef_cookie_manager_t* cef_cookie_manager_get_global_manager (
-    _cef_completion_callback_t* callback);
-
-///
-// Structure to implement for visiting cookie values. The functions of this
-// structure will always be called on the UI thread.
-///
-struct _cef_cookie_visitor_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be called once for each cookie. |count| is the 0-based
-    // index for the current cookie. |total| is the total number of cookies. Set
-    // |deleteCookie| to true (1) to delete the cookie currently being visited.
-    // Return false (0) to stop visiting cookies. This function may never be
-    // called if no cookies are found.
-    ///
-    int function (
-        _cef_cookie_visitor_t* self,
-        const(_cef_cookie_t)* cookie,
-        int count,
-        int total,
-        int* deleteCookie) nothrow visit;
-}
-
-alias cef_cookie_visitor_t = _cef_cookie_visitor_t;
-
-///
-// Structure to implement to be notified of asynchronous completion via
-// cef_cookie_manager_t::set_cookie().
-///
-struct _cef_set_cookie_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be called upon completion. |success| will be true (1) if
-    // the cookie was set successfully.
-    ///
-    void function (_cef_set_cookie_callback_t* self, int success) nothrow on_complete;
-}
-
-alias cef_set_cookie_callback_t = _cef_set_cookie_callback_t;
-
-///
-// Structure to implement to be notified of asynchronous completion via
-// cef_cookie_manager_t::delete_cookies().
-///
-struct _cef_delete_cookies_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be called upon completion. |num_deleted| will be the
-    // number of cookies that were deleted.
-    ///
-    void function (
-        _cef_delete_cookies_callback_t* self,
-        int num_deleted) nothrow on_complete;
-}
-
-alias cef_delete_cookies_callback_t = _cef_delete_cookies_callback_t;
-
-// CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=2b24c7d99c59c669719b822f5ea19763d140b001$
-//
-
-extern (C):
-
-///
-// Crash reporting is configured using an INI-style config file named
-// "crash_reporter.cfg". On Windows and Linux this file must be placed next to
-// the main application executable. On macOS this file must be placed in the
-// top-level app bundle Resources directory (e.g.
-// "<appname>.app/Contents/Resources"). File contents are as follows:
-//
-//  # Comments start with a hash character and must be on their own line.
-//
-//  [Config]
-//  ProductName=<Value of the "prod" crash key; defaults to "cef">
-//  ProductVersion=<Value of the "ver" crash key; defaults to the CEF version>
-//  AppName=<Windows only; App-specific folder name component for storing crash
-//           information; default to "CEF">
-//  ExternalHandler=<Windows only; Name of the external handler exe to use
-//                   instead of re-launching the main exe; default to empty>
-//  BrowserCrashForwardingEnabled=<macOS only; True if browser process crashes
-//                                 should be forwarded to the system crash
-//                                 reporter; default to false>
-//  ServerURL=<crash server URL; default to empty>
-//  RateLimitEnabled=<True if uploads should be rate limited; default to true>
-//  MaxUploadsPerDay=<Max uploads per 24 hours, used if rate limit is enabled;
-//                    default to 5>
-//  MaxDatabaseSizeInMb=<Total crash report disk usage greater than this value
-//                       will cause older reports to be deleted; default to 20>
-//  MaxDatabaseAgeInDays=<Crash reports older than this value will be deleted;
-//                        default to 5>
-//
-//  [CrashKeys]
-//  my_key1=<small|medium|large>
-//  my_key2=<small|medium|large>
-//
-// Config section:
-//
-// If "ProductName" and/or "ProductVersion" are set then the specified values
-// will be included in the crash dump metadata. On macOS if these values are set
-// to NULL then they will be retrieved from the Info.plist file using the
-// "CFBundleName" and "CFBundleShortVersionString" keys respectively.
-//
-// If "AppName" is set on Windows then crash report information (metrics,
-// database and dumps) will be stored locally on disk under the
-// "C:\Users\[CurrentUser]\AppData\Local\[AppName]\User Data" folder. On other
-// platforms the CefSettings.user_data_path value will be used.
-//
-// If "ExternalHandler" is set on Windows then the specified exe will be
-// launched as the crashpad-handler instead of re-launching the main process
-// exe. The value can be an absolute path or a path relative to the main exe
-// directory. On Linux the CefSettings.browser_subprocess_path value will be
-// used. On macOS the existing subprocess app bundle will be used.
-//
-// If "BrowserCrashForwardingEnabled" is set to true (1) on macOS then browser
-// process crashes will be forwarded to the system crash reporter. This results
-// in the crash UI dialog being displayed to the user and crash reports being
-// logged under "~/Library/Logs/DiagnosticReports". Forwarding of crash reports
-// from non-browser processes and Debug builds is always disabled.
-//
-// If "ServerURL" is set then crashes will be uploaded as a multi-part POST
-// request to the specified URL. Otherwise, reports will only be stored locally
-// on disk.
-//
-// If "RateLimitEnabled" is set to true (1) then crash report uploads will be
-// rate limited as follows:
-//  1. If "MaxUploadsPerDay" is set to a positive value then at most the
-//     specified number of crashes will be uploaded in each 24 hour period.
-//  2. If crash upload fails due to a network or server error then an
-//     incremental backoff delay up to a maximum of 24 hours will be applied for
-//     retries.
-//  3. If a backoff delay is applied and "MaxUploadsPerDay" is > 1 then the
-//     "MaxUploadsPerDay" value will be reduced to 1 until the client is
-//     restarted. This helps to avoid an upload flood when the network or
-//     server error is resolved.
-// Rate limiting is not supported on Linux.
-//
-// If "MaxDatabaseSizeInMb" is set to a positive value then crash report storage
-// on disk will be limited to that size in megabytes. For example, on Windows
-// each dump is about 600KB so a "MaxDatabaseSizeInMb" value of 20 equates to
-// about 34 crash reports stored on disk. Not supported on Linux.
-//
-// If "MaxDatabaseAgeInDays" is set to a positive value then crash reports older
-// than the specified age in days will be deleted. Not supported on Linux.
-//
-// CrashKeys section:
-//
-// A maximum of 26 crash keys of each size can be specified for use by the
-// application. Crash key values will be truncated based on the specified size
-// (small = 64 bytes, medium = 256 bytes, large = 1024 bytes). The value of
-// crash keys can be set from any thread or process using the
-// CefSetCrashKeyValue function. These key/value pairs will be sent to the crash
-// server along with the crash dump file.
-///
-int cef_crash_reporting_enabled ();
-
-///
-// Sets or clears a specific key-value pair from the crash metadata.
-///
-void cef_set_crash_key_value (
-    const(cef_string_t)* key,
-    const(cef_string_t)* value);
-
-// CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=86906c2e971fea7e479738f59bbf85d71ce31953$
-//
-
-extern (C):
-
-///
-// Callback structure for cef_browser_host_t::AddDevToolsMessageObserver. The
-// functions of this structure will be called on the browser process UI thread.
-///
-struct _cef_dev_tools_message_observer_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be called on receipt of a DevTools protocol message.
-    // |browser| is the originating browser instance. |message| is a UTF8-encoded
-    // JSON dictionary representing either a function result or an event.
-    // |message| is only valid for the scope of this callback and should be copied
-    // if necessary. Return true (1) if the message was handled or false (0) if
-    // the message should be further processed and passed to the
-    // OnDevToolsMethodResult or OnDevToolsEvent functions as appropriate.
-    //
-    // Method result dictionaries include an "id" (int) value that identifies the
-    // orginating function call sent from cef_browser_host_t::SendDevToolsMessage,
-    // and optionally either a "result" (dictionary) or "error" (dictionary)
-    // value. The "error" dictionary will contain "code" (int) and "message"
-    // (string) values. Event dictionaries include a "function" (string) value and
-    // optionally a "params" (dictionary) value. See the DevTools protocol
-    // documentation at https://chromedevtools.github.io/devtools-protocol/ for
-    // details of supported function calls and the expected "result" or "params"
-    // dictionary contents. JSON dictionaries can be parsed using the CefParseJSON
-    // function if desired, however be aware of performance considerations when
-    // parsing large messages (some of which may exceed 1MB in size).
-    ///
-    int function (
-        _cef_dev_tools_message_observer_t* self,
-        _cef_browser_t* browser,
-        const(void)* message,
-        size_t message_size) nothrow on_dev_tools_message;
-
-    ///
-    // Method that will be called after attempted execution of a DevTools protocol
-    // function. |browser| is the originating browser instance. |message_id| is
-    // the "id" value that identifies the originating function call message. If
-    // the function succeeded |success| will be true (1) and |result| will be the
-    // UTF8-encoded JSON "result" dictionary value (which may be NULL). If the
-    // function failed |success| will be false (0) and |result| will be the
-    // UTF8-encoded JSON "error" dictionary value. |result| is only valid for the
-    // scope of this callback and should be copied if necessary. See the
-    // OnDevToolsMessage documentation for additional details on |result|
-    // contents.
-    ///
-    void function (
-        _cef_dev_tools_message_observer_t* self,
-        _cef_browser_t* browser,
-        int message_id,
-        int success,
-        const(void)* result,
-        size_t result_size) nothrow on_dev_tools_method_result;
-
-    ///
-    // Method that will be called on receipt of a DevTools protocol event.
-    // |browser| is the originating browser instance. |function| is the "function"
-    // value. |params| is the UTF8-encoded JSON "params" dictionary value (which
-    // may be NULL). |params| is only valid for the scope of this callback and
-    // should be copied if necessary. See the OnDevToolsMessage documentation for
-    // additional details on |params| contents.
-    ///
-    void function (
-        _cef_dev_tools_message_observer_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* method,
-        const(void)* params,
-        size_t params_size) nothrow on_dev_tools_event;
-
-    ///
-    // Method that will be called when the DevTools agent has attached. |browser|
-    // is the originating browser instance. This will generally occur in response
-    // to the first message sent while the agent is detached.
-    ///
-    void function (
-        _cef_dev_tools_message_observer_t* self,
-        _cef_browser_t* browser) nothrow on_dev_tools_agent_attached;
-
-    ///
-    // Method that will be called when the DevTools agent has detached. |browser|
-    // is the originating browser instance. Any function results that were pending
-    // before the agent became detached will not be delivered, and any active
-    // event subscriptions will be canceled.
-    ///
-    void function (
-        _cef_dev_tools_message_observer_t* self,
-        _cef_browser_t* browser) nothrow on_dev_tools_agent_detached;
-}
-
-alias cef_dev_tools_message_observer_t = _cef_dev_tools_message_observer_t;
-
-// CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=3253c217564ae9a85a1e971298c32a35e4cad136$
-//
-
-extern (C):
-
-///
-// Callback structure for asynchronous continuation of file dialog requests.
-///
-struct _cef_file_dialog_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Continue the file selection. |selected_accept_filter| should be the 0-based
-    // index of the value selected from the accept filters array passed to
-    // cef_dialog_handler_t::OnFileDialog. |file_paths| should be a single value
-    // or a list of values depending on the dialog mode. An NULL |file_paths|
-    // value is treated the same as calling cancel().
-    ///
-    void function (
-        _cef_file_dialog_callback_t* self,
-        int selected_accept_filter,
-        cef_string_list_t file_paths) nothrow cont;
-
-    ///
-    // Cancel the file selection.
-    ///
-    void function (_cef_file_dialog_callback_t* self) nothrow cancel;
-}
-
-alias cef_file_dialog_callback_t = _cef_file_dialog_callback_t;
-
-///
-// Implement this structure to handle dialog events. The functions of this
-// structure will be called on the browser process UI thread.
-///
-struct _cef_dialog_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called to run a file chooser dialog. |mode| represents the type of dialog
-    // to display. |title| to the title to be used for the dialog and may be NULL
-    // to show the default title ("Open" or "Save" depending on the mode).
-    // |default_file_path| is the path with optional directory and/or file name
-    // component that should be initially selected in the dialog. |accept_filters|
-    // are used to restrict the selectable file types and may any combination of
-    // (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"), (b)
-    // individual file extensions (e.g. ".txt" or ".png"), or (c) combined
-    // description and file extension delimited using "|" and ";" (e.g. "Image
-    // Types|.png;.gif;.jpg"). |selected_accept_filter| is the 0-based index of
-    // the filter that should be selected by default. To display a custom dialog
-    // return true (1) and execute |callback| either inline or at a later time. To
-    // display the default dialog return false (0).
-    ///
-    int function (
-        _cef_dialog_handler_t* self,
-        _cef_browser_t* browser,
-        cef_file_dialog_mode_t mode,
-        const(cef_string_t)* title,
-        const(cef_string_t)* default_file_path,
-        cef_string_list_t accept_filters,
-        int selected_accept_filter,
-        _cef_file_dialog_callback_t* callback) nothrow on_file_dialog;
-}
-
-alias cef_dialog_handler_t = _cef_dialog_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=eada7e92085d96497f4e69f3e8a7e8aa6746b175$
-//
-
-import core.stdc.config;
-
-extern (C):
-
-///
-// Implement this structure to handle events related to browser display state.
-// The functions of this structure will be called on the UI thread.
-///
-struct _cef_display_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called when a frame's address has changed.
-    ///
-    void function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        const(cef_string_t)* url) nothrow on_address_change;
-
-    ///
-    // Called when the page title changes.
-    ///
-    void function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* title) nothrow on_title_change;
-
-    ///
-    // Called when the page icon changes.
-    ///
-    void function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        cef_string_list_t icon_urls) nothrow on_favicon_urlchange;
-
-    ///
-    // Called when web content in the page has toggled fullscreen mode. If
-    // |fullscreen| is true (1) the content will automatically be sized to fill
-    // the browser content area. If |fullscreen| is false (0) the content will
-    // automatically return to its original size and position. The client is
-    // responsible for resizing the browser if desired.
-    ///
-    void function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        int fullscreen) nothrow on_fullscreen_mode_change;
-
-    ///
-    // Called when the browser is about to display a tooltip. |text| contains the
-    // text that will be displayed in the tooltip. To handle the display of the
-    // tooltip yourself return true (1). Otherwise, you can optionally modify
-    // |text| and then return false (0) to allow the browser to display the
-    // tooltip. When window rendering is disabled the application is responsible
-    // for drawing tooltips and the return value is ignored.
-    ///
-    int function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        cef_string_t* text) nothrow on_tooltip;
-
-    ///
-    // Called when the browser receives a status message. |value| contains the
-    // text that will be displayed in the status message.
-    ///
-    void function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* value) nothrow on_status_message;
-
-    ///
-    // Called to display a console message. Return true (1) to stop the message
-    // from being output to the console.
-    ///
-    int function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        cef_log_severity_t level,
-        const(cef_string_t)* message,
-        const(cef_string_t)* source,
-        int line) nothrow on_console_message;
-
-    ///
-    // Called when auto-resize is enabled via
-    // cef_browser_host_t::SetAutoResizeEnabled and the contents have auto-
-    // resized. |new_size| will be the desired size in view coordinates. Return
-    // true (1) if the resize was handled or false (0) for default handling.
-    ///
-    int function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_size_t)* new_size) nothrow on_auto_resize;
-
-    ///
-    // Called when the overall page loading progress has changed. |progress|
-    // ranges from 0.0 to 1.0.
-    ///
-    void function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        double progress) nothrow on_loading_progress_change;
-
-    ///
-    // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
-    // |custom_cursor_info| will be populated with the custom cursor information.
-    // Return true (1) if the cursor change was handled or false (0) for default
-    // handling.
-    ///
-    int function (
-        _cef_display_handler_t* self,
-        _cef_browser_t* browser,
-        c_ulong cursor,
-        cef_cursor_type_t type,
-        const(_cef_cursor_info_t)* custom_cursor_info) nothrow on_cursor_change;
-}
-
-alias cef_display_handler_t = _cef_display_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=055c506e7950abba3ec1c12adbbb1a9989cf5ac5$
-//
-
-extern (C):
-
-///
-// Structure to implement for visiting the DOM. The functions of this structure
-// will be called on the render process main thread.
-///
-struct _cef_domvisitor_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method executed for visiting the DOM. The document object passed to this
-    // function represents a snapshot of the DOM at the time this function is
-    // executed. DOM objects are only valid for the scope of this function. Do not
-    // keep references to or attempt to access any DOM objects outside the scope
-    // of this function.
-    ///
-    void function (
-        _cef_domvisitor_t* self,
-        _cef_domdocument_t* document) nothrow visit;
-}
-
-alias cef_domvisitor_t = _cef_domvisitor_t;
-
-///
-// Structure used to represent a DOM document. The functions of this structure
-// should only be called on the render process main thread thread.
-///
-struct _cef_domdocument_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the document type.
-    ///
-    cef_dom_document_type_t function (_cef_domdocument_t* self) nothrow get_type;
-
-    ///
-    // Returns the root document node.
-    ///
-    _cef_domnode_t* function (_cef_domdocument_t* self) nothrow get_document;
-
-    ///
-    // Returns the BODY node of an HTML document.
-    ///
-    _cef_domnode_t* function (_cef_domdocument_t* self) nothrow get_body;
-
-    ///
-    // Returns the HEAD node of an HTML document.
-    ///
-    _cef_domnode_t* function (_cef_domdocument_t* self) nothrow get_head;
-
-    ///
-    // Returns the title of an HTML document.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_domdocument_t* self) nothrow get_title;
-
-    ///
-    // Returns the document element with the specified ID value.
-    ///
-    _cef_domnode_t* function (
-        _cef_domdocument_t* self,
-        const(cef_string_t)* id) nothrow get_element_by_id;
-
-    ///
-    // Returns the node that currently has keyboard focus.
-    ///
-    _cef_domnode_t* function (_cef_domdocument_t* self) nothrow get_focused_node;
-
-    ///
-    // Returns true (1) if a portion of the document is selected.
-    ///
-    int function (_cef_domdocument_t* self) nothrow has_selection;
-
-    ///
-    // Returns the selection offset within the start node.
-    ///
-    int function (_cef_domdocument_t* self) nothrow get_selection_start_offset;
-
-    ///
-    // Returns the selection offset within the end node.
-    ///
-    int function (_cef_domdocument_t* self) nothrow get_selection_end_offset;
-
-    ///
-    // Returns the contents of this selection as markup.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_domdocument_t* self) nothrow get_selection_as_markup;
-
-    ///
-    // Returns the contents of this selection as text.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_domdocument_t* self) nothrow get_selection_as_text;
-
-    ///
-    // Returns the base URL for the document.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_domdocument_t* self) nothrow get_base_url;
-
-    ///
-    // Returns a complete URL based on the document base URL and the specified
-    // partial URL.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_domdocument_t* self,
-        const(cef_string_t)* partialURL) nothrow get_complete_url;
-}
-
-alias cef_domdocument_t = _cef_domdocument_t;
-
-///
-// Structure used to represent a DOM node. The functions of this structure
-// should only be called on the render process main thread.
-///
-struct _cef_domnode_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the type for this node.
-    ///
-    cef_dom_node_type_t function (_cef_domnode_t* self) nothrow get_type;
-
-    ///
-    // Returns true (1) if this is a text node.
-    ///
-    int function (_cef_domnode_t* self) nothrow is_text;
-
-    ///
-    // Returns true (1) if this is an element node.
-    ///
-    int function (_cef_domnode_t* self) nothrow is_element;
-
-    ///
-    // Returns true (1) if this is an editable node.
-    ///
-    int function (_cef_domnode_t* self) nothrow is_editable;
-
-    ///
-    // Returns true (1) if this is a form control element node.
-    ///
-    int function (_cef_domnode_t* self) nothrow is_form_control_element;
-
-    ///
-    // Returns the type of this form control element node.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_domnode_t* self) nothrow get_form_control_element_type;
-
-    ///
-    // Returns true (1) if this object is pointing to the same handle as |that|
-    // object.
-    ///
-    int function (_cef_domnode_t* self, _cef_domnode_t* that) nothrow is_same;
-
-    ///
-    // Returns the name of this node.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_domnode_t* self) nothrow get_name;
-
-    ///
-    // Returns the value of this node.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_domnode_t* self) nothrow get_value;
-
-    ///
-    // Set the value of this node. Returns true (1) on success.
-    ///
-    int function (_cef_domnode_t* self, const(cef_string_t)* value) nothrow set_value;
-
-    ///
-    // Returns the contents of this node as markup.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_domnode_t* self) nothrow get_as_markup;
-
-    ///
-    // Returns the document associated with this node.
-    ///
-    _cef_domdocument_t* function (_cef_domnode_t* self) nothrow get_document;
-
-    ///
-    // Returns the parent node.
-    ///
-    _cef_domnode_t* function (_cef_domnode_t* self) nothrow get_parent;
-
-    ///
-    // Returns the previous sibling node.
-    ///
-    _cef_domnode_t* function (_cef_domnode_t* self) nothrow get_previous_sibling;
-
-    ///
-    // Returns the next sibling node.
-    ///
-    _cef_domnode_t* function (_cef_domnode_t* self) nothrow get_next_sibling;
-
-    ///
-    // Returns true (1) if this node has child nodes.
-    ///
-    int function (_cef_domnode_t* self) nothrow has_children;
-
-    ///
-    // Return the first child node.
-    ///
-    _cef_domnode_t* function (_cef_domnode_t* self) nothrow get_first_child;
-
-    ///
-    // Returns the last child node.
-    ///
-    _cef_domnode_t* function (_cef_domnode_t* self) nothrow get_last_child;
-
-    // The following functions are valid only for element nodes.
-
-    ///
-    // Returns the tag name of this element.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_domnode_t* self) nothrow get_element_tag_name;
-
-    ///
-    // Returns true (1) if this element has attributes.
-    ///
-    int function (_cef_domnode_t* self) nothrow has_element_attributes;
-
-    ///
-    // Returns true (1) if this element has an attribute named |attrName|.
-    ///
-    int function (
-        _cef_domnode_t* self,
-        const(cef_string_t)* attrName) nothrow has_element_attribute;
-
-    ///
-    // Returns the element attribute named |attrName|.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_domnode_t* self,
-        const(cef_string_t)* attrName) nothrow get_element_attribute;
-
-    ///
-    // Returns a map of all element attributes.
-    ///
-    void function (
-        _cef_domnode_t* self,
-        cef_string_map_t attrMap) nothrow get_element_attributes;
-
-    ///
-    // Set the value for the element attribute named |attrName|. Returns true (1)
-    // on success.
-    ///
-    int function (
-        _cef_domnode_t* self,
-        const(cef_string_t)* attrName,
-        const(cef_string_t)* value) nothrow set_element_attribute;
-
-    ///
-    // Returns the inner text of the element.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_domnode_t* self) nothrow get_element_inner_text;
-
-    ///
-    // Returns the bounds of the element.
-    ///
-    cef_rect_t function (_cef_domnode_t* self) nothrow get_element_bounds;
-}
-
-alias cef_domnode_t = _cef_domnode_t;
-
-// CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=3399f17cc69d8fbd5c09f63f81680aa1f68454f0$
-//
-
-extern (C):
-
-///
-// Callback structure used to asynchronously continue a download.
-///
-struct _cef_before_download_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Call to continue the download. Set |download_path| to the full file path
-    // for the download including the file name or leave blank to use the
-    // suggested name and the default temp directory. Set |show_dialog| to true
-    // (1) if you do wish to show the default "Save As" dialog.
-    ///
-    void function (
-        _cef_before_download_callback_t* self,
-        const(cef_string_t)* download_path,
-        int show_dialog) nothrow cont;
-}
-
-alias cef_before_download_callback_t = _cef_before_download_callback_t;
-
-///
-// Callback structure used to asynchronously cancel a download.
-///
-struct _cef_download_item_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Call to cancel the download.
-    ///
-    void function (_cef_download_item_callback_t* self) nothrow cancel;
-
-    ///
-    // Call to pause the download.
-    ///
-    void function (_cef_download_item_callback_t* self) nothrow pause;
-
-    ///
-    // Call to resume the download.
-    ///
-    void function (_cef_download_item_callback_t* self) nothrow resume;
-}
-
-alias cef_download_item_callback_t = _cef_download_item_callback_t;
-
-///
-// Structure used to handle file downloads. The functions of this structure will
-// called on the browser process UI thread.
-///
-struct _cef_download_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called before a download begins. |suggested_name| is the suggested name for
-    // the download file. By default the download will be canceled. Execute
-    // |callback| either asynchronously or in this function to continue the
-    // download if desired. Do not keep a reference to |download_item| outside of
-    // this function.
-    ///
-    void function (
-        _cef_download_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_download_item_t* download_item,
-        const(cef_string_t)* suggested_name,
-        _cef_before_download_callback_t* callback) nothrow on_before_download;
-
-    ///
-    // Called when a download's status or progress information has been updated.
-    // This may be called multiple times before and after on_before_download().
-    // Execute |callback| either asynchronously or in this function to cancel the
-    // download if desired. Do not keep a reference to |download_item| outside of
-    // this function.
-    ///
-    void function (
-        _cef_download_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_download_item_t* download_item,
-        _cef_download_item_callback_t* callback) nothrow on_download_updated;
-}
-
-alias cef_download_handler_t = _cef_download_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=d6366977af5e2a3a71b4f57042208ff7ed524c6c$
-//
-
-extern (C):
-
-///
-// Structure used to represent a download item.
-///
-struct _cef_download_item_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is valid. Do not call any other functions
-    // if this function returns false (0).
-    ///
-    int function (_cef_download_item_t* self) nothrow is_valid;
-
-    ///
-    // Returns true (1) if the download is in progress.
-    ///
-    int function (_cef_download_item_t* self) nothrow is_in_progress;
-
-    ///
-    // Returns true (1) if the download is complete.
-    ///
-    int function (_cef_download_item_t* self) nothrow is_complete;
-
-    ///
-    // Returns true (1) if the download has been canceled or interrupted.
-    ///
-    int function (_cef_download_item_t* self) nothrow is_canceled;
-
-    ///
-    // Returns a simple speed estimate in bytes/s.
-    ///
-    int64 function (_cef_download_item_t* self) nothrow get_current_speed;
-
-    ///
-    // Returns the rough percent complete or -1 if the receive total size is
-    // unknown.
-    ///
-    int function (_cef_download_item_t* self) nothrow get_percent_complete;
-
-    ///
-    // Returns the total number of bytes.
-    ///
-    int64 function (_cef_download_item_t* self) nothrow get_total_bytes;
-
-    ///
-    // Returns the number of received bytes.
-    ///
-    int64 function (_cef_download_item_t* self) nothrow get_received_bytes;
-
-    ///
-    // Returns the time that the download started.
-    ///
-    cef_time_t function (_cef_download_item_t* self) nothrow get_start_time;
-
-    ///
-    // Returns the time that the download ended.
-    ///
-    cef_time_t function (_cef_download_item_t* self) nothrow get_end_time;
-
-    ///
-    // Returns the full path to the downloaded or downloading file.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_download_item_t* self) nothrow get_full_path;
-
-    ///
-    // Returns the unique identifier for this download.
-    ///
-    uint32 function (_cef_download_item_t* self) nothrow get_id;
-
-    ///
-    // Returns the URL.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_download_item_t* self) nothrow get_url;
-
-    ///
-    // Returns the original URL before any redirections.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_download_item_t* self) nothrow get_original_url;
-
-    ///
-    // Returns the suggested file name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_download_item_t* self) nothrow get_suggested_file_name;
-
-    ///
-    // Returns the content disposition.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_download_item_t* self) nothrow get_content_disposition;
-
-    ///
-    // Returns the mime type.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_download_item_t* self) nothrow get_mime_type;
-}
-
-alias cef_download_item_t = _cef_download_item_t;
-
-// CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=6c8c654be3e69d872b3cfa6bdfb1adf615bff3ac$
-//
-
-extern (C):
-
-///
-// Structure used to represent drag data. The functions of this structure may be
-// called on any thread.
-///
-struct _cef_drag_data_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns a copy of the current object.
-    ///
-    _cef_drag_data_t* function (_cef_drag_data_t* self) nothrow clone;
-
-    ///
-    // Returns true (1) if this object is read-only.
-    ///
-    int function (_cef_drag_data_t* self) nothrow is_read_only;
-
-    ///
-    // Returns true (1) if the drag data is a link.
-    ///
-    int function (_cef_drag_data_t* self) nothrow is_link;
-
-    ///
-    // Returns true (1) if the drag data is a text or html fragment.
-    ///
-    int function (_cef_drag_data_t* self) nothrow is_fragment;
-
-    ///
-    // Returns true (1) if the drag data is a file.
-    ///
-    int function (_cef_drag_data_t* self) nothrow is_file;
-
-    ///
-    // Return the link URL that is being dragged.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_drag_data_t* self) nothrow get_link_url;
-
-    ///
-    // Return the title associated with the link being dragged.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_drag_data_t* self) nothrow get_link_title;
-
-    ///
-    // Return the metadata, if any, associated with the link being dragged.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_drag_data_t* self) nothrow get_link_metadata;
-
-    ///
-    // Return the plain text fragment that is being dragged.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_drag_data_t* self) nothrow get_fragment_text;
-
-    ///
-    // Return the text/html fragment that is being dragged.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_drag_data_t* self) nothrow get_fragment_html;
-
-    ///
-    // Return the base URL that the fragment came from. This value is used for
-    // resolving relative URLs and may be NULL.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_drag_data_t* self) nothrow get_fragment_base_url;
-
-    ///
-    // Return the name of the file being dragged out of the browser window.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_drag_data_t* self) nothrow get_file_name;
-
-    ///
-    // Write the contents of the file being dragged out of the web view into
-    // |writer|. Returns the number of bytes sent to |writer|. If |writer| is NULL
-    // this function will return the size of the file contents in bytes. Call
-    // get_file_name() to get a suggested name for the file.
-    ///
-    size_t function (
-        _cef_drag_data_t* self,
-        _cef_stream_writer_t* writer) nothrow get_file_contents;
-
-    ///
-    // Retrieve the list of file names that are being dragged into the browser
-    // window.
-    ///
-    int function (
-        _cef_drag_data_t* self,
-        cef_string_list_t names) nothrow get_file_names;
-
-    ///
-    // Set the link URL that is being dragged.
-    ///
-    void function (
-        _cef_drag_data_t* self,
-        const(cef_string_t)* url) nothrow set_link_url;
-
-    ///
-    // Set the title associated with the link being dragged.
-    ///
-    void function (
-        _cef_drag_data_t* self,
-        const(cef_string_t)* title) nothrow set_link_title;
-
-    ///
-    // Set the metadata associated with the link being dragged.
-    ///
-    void function (
-        _cef_drag_data_t* self,
-        const(cef_string_t)* data) nothrow set_link_metadata;
-
-    ///
-    // Set the plain text fragment that is being dragged.
-    ///
-    void function (
-        _cef_drag_data_t* self,
-        const(cef_string_t)* text) nothrow set_fragment_text;
-
-    ///
-    // Set the text/html fragment that is being dragged.
-    ///
-    void function (
-        _cef_drag_data_t* self,
-        const(cef_string_t)* html) nothrow set_fragment_html;
-
-    ///
-    // Set the base URL that the fragment came from.
-    ///
-    void function (
-        _cef_drag_data_t* self,
-        const(cef_string_t)* base_url) nothrow set_fragment_base_url;
-
-    ///
-    // Reset the file contents. You should do this before calling
-    // cef_browser_host_t::DragTargetDragEnter as the web view does not allow us
-    // to drag in this kind of data.
-    ///
-    void function (_cef_drag_data_t* self) nothrow reset_file_contents;
-
-    ///
-    // Add a file that is being dragged into the webview.
-    ///
-    void function (
-        _cef_drag_data_t* self,
-        const(cef_string_t)* path,
-        const(cef_string_t)* display_name) nothrow add_file;
-
-    ///
-    // Get the image representation of drag data. May return NULL if no image
-    // representation is available.
-    ///
-    _cef_image_t* function (_cef_drag_data_t* self) nothrow get_image;
-
-    ///
-    // Get the image hotspot (drag start location relative to image dimensions).
-    ///
-    cef_point_t function (_cef_drag_data_t* self) nothrow get_image_hotspot;
-
-    ///
-    // Returns true (1) if an image representation of drag data is available.
-    ///
-    int function (_cef_drag_data_t* self) nothrow has_image;
-}
-
-alias cef_drag_data_t = _cef_drag_data_t;
-
-///
-// Create a new cef_drag_data_t object.
-///
-cef_drag_data_t* cef_drag_data_create ();
-
-// CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=78022908355fbf836799545e67ce2e4663b85fdf$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle events related to dragging. The functions
-// of this structure will be called on the UI thread.
-///
-struct _cef_drag_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called when an external drag event enters the browser window. |dragData|
-    // contains the drag event data and |mask| represents the type of drag
-    // operation. Return false (0) for default drag handling behavior or true (1)
-    // to cancel the drag event.
-    ///
-    int function (
-        _cef_drag_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_drag_data_t* dragData,
-        cef_drag_operations_mask_t mask) nothrow on_drag_enter;
-
-    ///
-    // Called whenever draggable regions for the browser window change. These can
-    // be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If
-    // draggable regions are never defined in a document this function will also
-    // never be called. If the last draggable region is removed from a document
-    // this function will be called with an NULL vector.
-    ///
-    void function (
-        _cef_drag_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        size_t regionsCount,
-        const(cef_draggable_region_t)* regions) nothrow on_draggable_regions_changed;
-}
-
-alias cef_drag_handler_t = _cef_drag_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=b50087959cb679e4132f0fccfd23f01f76079018$
-//
-
-extern (C):
-
-///
-// Object representing an extension. Methods may be called on any thread unless
-// otherwise indicated.
-///
-struct _cef_extension_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the unique extension identifier. This is calculated based on the
-    // extension public key, if available, or on the extension path. See
-    // https://developer.chrome.com/extensions/manifest/key for details.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_extension_t* self) nothrow get_identifier;
-
-    ///
-    // Returns the absolute path to the extension directory on disk. This value
-    // will be prefixed with PK_DIR_RESOURCES if a relative path was passed to
-    // cef_request_context_t::LoadExtension.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_extension_t* self) nothrow get_path;
-
-    ///
-    // Returns the extension manifest contents as a cef_dictionary_value_t object.
-    // See https://developer.chrome.com/extensions/manifest for details.
-    ///
-    _cef_dictionary_value_t* function (_cef_extension_t* self) nothrow get_manifest;
-
-    ///
-    // Returns true (1) if this object is the same extension as |that| object.
-    // Extensions are considered the same if identifier, path and loader context
-    // match.
-    ///
-    int function (_cef_extension_t* self, _cef_extension_t* that) nothrow is_same;
-
-    ///
-    // Returns the handler for this extension. Will return NULL for internal
-    // extensions or if no handler was passed to
-    // cef_request_context_t::LoadExtension.
-    ///
-    _cef_extension_handler_t* function (_cef_extension_t* self) nothrow get_handler;
-
-    ///
-    // Returns the request context that loaded this extension. Will return NULL
-    // for internal extensions or if the extension has been unloaded. See the
-    // cef_request_context_t::LoadExtension documentation for more information
-    // about loader contexts. Must be called on the browser process UI thread.
-    ///
-    _cef_request_context_t* function (
-        _cef_extension_t* self) nothrow get_loader_context;
-
-    ///
-    // Returns true (1) if this extension is currently loaded. Must be called on
-    // the browser process UI thread.
-    ///
-    int function (_cef_extension_t* self) nothrow is_loaded;
-
-    ///
-    // Unload this extension if it is not an internal extension and is currently
-    // loaded. Will result in a call to
-    // cef_extension_handler_t::OnExtensionUnloaded on success.
-    ///
-    void function (_cef_extension_t* self) nothrow unload;
-}
-
-alias cef_extension_t = _cef_extension_t;
-
-// CEF_INCLUDE_CAPI_CEF_EXTENSION_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=c930140791b9e7d4238110e24fe17b9566a34ec9$
-//
-
-extern (C):
-
-///
-// Creates a directory and all parent directories if they don't already exist.
-// Returns true (1) on successful creation or if the directory already exists.
-// The directory is only readable by the current user. Calling this function on
-// the browser process UI or IO threads is not allowed.
-///
-int cef_create_directory (const(cef_string_t)* full_path);
-
-///
-// Get the temporary directory provided by the system.
-//
-// WARNING: In general, you should use the temp directory variants below instead
-// of this function. Those variants will ensure that the proper permissions are
-// set so that other users on the system can't edit them while they're open
-// (which could lead to security issues).
-///
-int cef_get_temp_directory (cef_string_t* temp_dir);
-
-///
-// Creates a new directory. On Windows if |prefix| is provided the new directory
-// name is in the format of "prefixyyyy". Returns true (1) on success and sets
-// |new_temp_path| to the full path of the directory that was created. The
-// directory is only readable by the current user. Calling this function on the
-// browser process UI or IO threads is not allowed.
-///
-int cef_create_new_temp_directory (
-    const(cef_string_t)* prefix,
-    cef_string_t* new_temp_path);
-
-///
-// Creates a directory within another directory. Extra characters will be
-// appended to |prefix| to ensure that the new directory does not have the same
-// name as an existing directory. Returns true (1) on success and sets |new_dir|
-// to the full path of the directory that was created. The directory is only
-// readable by the current user. Calling this function on the browser process UI
-// or IO threads is not allowed.
-///
-int cef_create_temp_directory_in_directory (
-    const(cef_string_t)* base_dir,
-    const(cef_string_t)* prefix,
-    cef_string_t* new_dir);
-
-///
-// Returns true (1) if the given path exists and is a directory. Calling this
-// function on the browser process UI or IO threads is not allowed.
-///
-int cef_directory_exists (const(cef_string_t)* path);
-
-///
-// Deletes the given path whether it's a file or a directory. If |path| is a
-// directory all contents will be deleted.  If |recursive| is true (1) any sub-
-// directories and their contents will also be deleted (equivalent to executing
-// "rm -rf", so use with caution). On POSIX environments if |path| is a symbolic
-// link then only the symlink will be deleted. Returns true (1) on successful
-// deletion or if |path| does not exist. Calling this function on the browser
-// process UI or IO threads is not allowed.
-///
-int cef_delete_file (const(cef_string_t)* path, int recursive);
-
-///
-// Writes the contents of |src_dir| into a zip archive at |dest_file|. If
-// |include_hidden_files| is true (1) files starting with "." will be included.
-// Returns true (1) on success.  Calling this function on the browser process UI
-// or IO threads is not allowed.
-///
-int cef_zip_directory (
-    const(cef_string_t)* src_dir,
-    const(cef_string_t)* dest_file,
-    int include_hidden_files);
-
-///
-// Loads the existing "Certificate Revocation Lists" file that is managed by
-// Google Chrome. This file can generally be found in Chrome's User Data
-// directory (e.g. "C:\Users\[User]\AppData\Local\Google\Chrome\User Data\" on
-// Windows) and is updated periodically by Chrome's component updater service.
-// Must be called in the browser process after the context has been initialized.
-// See https://dev.chromium.org/Home/chromium-security/crlsets for background.
-///
-void cef_load_crlsets_file (const(cef_string_t)* path);
-
-// CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=2aa57426a91e10985a5e92830bc3bcd9287708d4$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle events related to find results. The
-// functions of this structure will be called on the UI thread.
-///
-struct _cef_find_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called to report find results returned by cef_browser_host_t::find().
-    // |identifer| is the identifier passed to find(), |count| is the number of
-    // matches currently identified, |selectionRect| is the location of where the
-    // match was found (in window coordinates), |activeMatchOrdinal| is the
-    // current position in the search results, and |finalUpdate| is true (1) if
-    // this is the last find notification.
-    ///
-    void function (
-        _cef_find_handler_t* self,
-        _cef_browser_t* browser,
-        int identifier,
-        int count,
-        const(cef_rect_t)* selectionRect,
-        int activeMatchOrdinal,
-        int finalUpdate) nothrow on_find_result;
-}
-
-alias cef_find_handler_t = _cef_find_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=091dd994f37070e9d7c27d0e2f7411ea9cf068f5$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle events related to focus. The functions of
-// this structure will be called on the UI thread.
-///
-struct _cef_focus_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called when the browser component is about to loose focus. For instance, if
-    // focus was on the last HTML element and the user pressed the TAB key. |next|
-    // will be true (1) if the browser is giving focus to the next component and
-    // false (0) if the browser is giving focus to the previous component.
-    ///
-    void function (
-        _cef_focus_handler_t* self,
-        _cef_browser_t* browser,
-        int next) nothrow on_take_focus;
-
-    ///
-    // Called when the browser component is requesting focus. |source| indicates
-    // where the focus request is originating from. Return false (0) to allow the
-    // focus to be set or true (1) to cancel setting the focus.
-    ///
-    int function (
-        _cef_focus_handler_t* self,
-        _cef_browser_t* browser,
-        cef_focus_source_t source) nothrow on_set_focus;
-
-    ///
-    // Called when the browser component has received focus.
-    ///
-    void function (
-        _cef_focus_handler_t* self,
-        _cef_browser_t* browser) nothrow on_got_focus;
-}
-
-alias cef_focus_handler_t = _cef_focus_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=d8f114b44d02d96b5da0ec399c99091b9ceb6871$
-//
-
-extern (C):
-
-///
-// Structure used to represent a frame in the browser window. When used in the
-// browser process the functions of this structure may be called on any thread
-// unless otherwise indicated in the comments. When used in the render process
-// the functions of this structure may only be called on the main thread.
-///
-struct _cef_frame_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // True if this object is currently attached to a valid frame.
-    ///
-    int function (_cef_frame_t* self) nothrow is_valid;
-
-    ///
-    // Execute undo in this frame.
-    ///
-    void function (_cef_frame_t* self) nothrow undo;
-
-    ///
-    // Execute redo in this frame.
-    ///
-    void function (_cef_frame_t* self) nothrow redo;
-
-    ///
-    // Execute cut in this frame.
-    ///
-    void function (_cef_frame_t* self) nothrow cut;
-
-    ///
-    // Execute copy in this frame.
-    ///
-    void function (_cef_frame_t* self) nothrow copy;
-
-    ///
-    // Execute paste in this frame.
-    ///
-    void function (_cef_frame_t* self) nothrow paste;
-
-    ///
-    // Execute delete in this frame.
-    ///
-    void function (_cef_frame_t* self) nothrow del;
-
-    ///
-    // Execute select all in this frame.
-    ///
-    void function (_cef_frame_t* self) nothrow select_all;
-
-    ///
-    // Save this frame's HTML source to a temporary file and open it in the
-    // default text viewing application. This function can only be called from the
-    // browser process.
-    ///
-    void function (_cef_frame_t* self) nothrow view_source;
-
-    ///
-    // Retrieve this frame's HTML source as a string sent to the specified
-    // visitor.
-    ///
-    void function (
-        _cef_frame_t* self,
-        _cef_string_visitor_t* visitor) nothrow get_source;
-
-    ///
-    // Retrieve this frame's display text as a string sent to the specified
-    // visitor.
-    ///
-    void function (
-        _cef_frame_t* self,
-        _cef_string_visitor_t* visitor) nothrow get_text;
-
-    ///
-    // Load the request represented by the |request| object.
-    //
-    // WARNING: This function will fail with "bad IPC message" reason
-    // INVALID_INITIATOR_ORIGIN (213) unless you first navigate to the request
-    // origin using some other mechanism (LoadURL, link click, etc).
-    ///
-    void function (_cef_frame_t* self, _cef_request_t* request) nothrow load_request;
-
-    ///
-    // Load the specified |url|.
-    ///
-    void function (_cef_frame_t* self, const(cef_string_t)* url) nothrow load_url;
-
-    ///
-    // Execute a string of JavaScript code in this frame. The |script_url|
-    // parameter is the URL where the script in question can be found, if any. The
-    // renderer may request this URL to show the developer the source of the
-    // error.  The |start_line| parameter is the base line number to use for error
-    // reporting.
-    ///
-    void function (
-        _cef_frame_t* self,
-        const(cef_string_t)* code,
-        const(cef_string_t)* script_url,
-        int start_line) nothrow execute_java_script;
-
-    ///
-    // Returns true (1) if this is the main (top-level) frame.
-    ///
-    int function (_cef_frame_t* self) nothrow is_main;
-
-    ///
-    // Returns true (1) if this is the focused frame.
-    ///
-    int function (_cef_frame_t* self) nothrow is_focused;
-
-    ///
-    // Returns the name for this frame. If the frame has an assigned name (for
-    // example, set via the iframe "name" attribute) then that value will be
-    // returned. Otherwise a unique name will be constructed based on the frame
-    // parent hierarchy. The main (top-level) frame will always have an NULL name
-    // value.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_frame_t* self) nothrow get_name;
-
-    ///
-    // Returns the globally unique identifier for this frame or < 0 if the
-    // underlying frame does not yet exist.
-    ///
-    int64 function (_cef_frame_t* self) nothrow get_identifier;
-
-    ///
-    // Returns the parent of this frame or NULL if this is the main (top-level)
-    // frame.
-    ///
-    _cef_frame_t* function (_cef_frame_t* self) nothrow get_parent;
-
-    ///
-    // Returns the URL currently loaded in this frame.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_frame_t* self) nothrow get_url;
-
-    ///
-    // Returns the browser that this frame belongs to.
-    ///
-    _cef_browser_t* function (_cef_frame_t* self) nothrow get_browser;
-
-    ///
-    // Get the V8 context associated with the frame. This function can only be
-    // called from the render process.
-    ///
-    _cef_v8context_t* function (_cef_frame_t* self) nothrow get_v8context;
-
-    ///
-    // Visit the DOM document. This function can only be called from the render
-    // process.
-    ///
-    void function (_cef_frame_t* self, _cef_domvisitor_t* visitor) nothrow visit_dom;
-
-    ///
-    // Create a new URL request that will be treated as originating from this
-    // frame and the associated browser. This request may be intercepted by the
-    // client via cef_resource_request_handler_t or cef_scheme_handler_factory_t.
-    // Use cef_urlrequest_t::Create instead if you do not want the request to have
-    // this association, in which case it may be handled differently (see
-    // documentation on that function). Requests may originate from both the
-    // browser process and the render process.
-    //
-    // For requests originating from the browser process:
-    //   - POST data may only contain a single element of type PDE_TYPE_FILE or
-    //     PDE_TYPE_BYTES.
-    // For requests originating from the render process:
-    //   - POST data may only contain a single element of type PDE_TYPE_BYTES.
-    //   - If the response contains Content-Disposition or Mime-Type header values
-    //     that would not normally be rendered then the response may receive
-    //     special handling inside the browser (for example, via the file download
-    //     code path instead of the URL request code path).
-    //
-    // The |request| object will be marked as read-only after calling this
-    // function.
-    ///
-    _cef_urlrequest_t* function (
-        _cef_frame_t* self,
-        _cef_request_t* request,
-        _cef_urlrequest_client_t* client) nothrow create_urlrequest;
-
-    ///
-    // Send a message to the specified |target_process|. Message delivery is not
-    // guaranteed in all cases (for example, if the browser is closing,
-    // navigating, or if the target process crashes). Send an ACK message back
-    // from the target process if confirmation is required.
-    ///
-    void function (
-        _cef_frame_t* self,
-        cef_process_id_t target_process,
-        _cef_process_message_t* message) nothrow send_process_message;
-}
-
-alias cef_frame_t = _cef_frame_t;
-
-// CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=5afa8e95e6e7bddbd3c442e99b4c2843efb18c49$
-//
-
-extern (C):
-
-///
-// Container for a single image represented at different scale factors. All
-// image representations should be the same size in density independent pixel
-// (DIP) units. For example, if the image at scale factor 1.0 is 100x100 pixels
-// then the image at scale factor 2.0 should be 200x200 pixels -- both images
-// will display with a DIP size of 100x100 units. The functions of this
-// structure can be called on any browser process thread.
-///
-struct _cef_image_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this Image is NULL.
-    ///
-    int function (_cef_image_t* self) nothrow is_empty;
-
-    ///
-    // Returns true (1) if this Image and |that| Image share the same underlying
-    // storage. Will also return true (1) if both images are NULL.
-    ///
-    int function (_cef_image_t* self, _cef_image_t* that) nothrow is_same;
-
-    ///
-    // Add a bitmap image representation for |scale_factor|. Only 32-bit RGBA/BGRA
-    // formats are supported. |pixel_width| and |pixel_height| are the bitmap
-    // representation size in pixel coordinates. |pixel_data| is the array of
-    // pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in size.
-    // |color_type| and |alpha_type| values specify the pixel format.
-    ///
-    int function (
-        _cef_image_t* self,
-        float scale_factor,
-        int pixel_width,
-        int pixel_height,
-        cef_color_type_t color_type,
-        cef_alpha_type_t alpha_type,
-        const(void)* pixel_data,
-        size_t pixel_data_size) nothrow add_bitmap;
-
-    ///
-    // Add a PNG image representation for |scale_factor|. |png_data| is the image
-    // data of size |png_data_size|. Any alpha transparency in the PNG data will
-    // be maintained.
-    ///
-    int function (
-        _cef_image_t* self,
-        float scale_factor,
-        const(void)* png_data,
-        size_t png_data_size) nothrow add_png;
-
-    ///
-    // Create a JPEG image representation for |scale_factor|. |jpeg_data| is the
-    // image data of size |jpeg_data_size|. The JPEG format does not support
-    // transparency so the alpha byte will be set to 0xFF for all pixels.
-    ///
-    int function (
-        _cef_image_t* self,
-        float scale_factor,
-        const(void)* jpeg_data,
-        size_t jpeg_data_size) nothrow add_jpeg;
-
-    ///
-    // Returns the image width in density independent pixel (DIP) units.
-    ///
-    size_t function (_cef_image_t* self) nothrow get_width;
-
-    ///
-    // Returns the image height in density independent pixel (DIP) units.
-    ///
-    size_t function (_cef_image_t* self) nothrow get_height;
-
-    ///
-    // Returns true (1) if this image contains a representation for
-    // |scale_factor|.
-    ///
-    int function (_cef_image_t* self, float scale_factor) nothrow has_representation;
-
-    ///
-    // Removes the representation for |scale_factor|. Returns true (1) on success.
-    ///
-    int function (
-        _cef_image_t* self,
-        float scale_factor) nothrow remove_representation;
-
-    ///
-    // Returns information for the representation that most closely matches
-    // |scale_factor|. |actual_scale_factor| is the actual scale factor for the
-    // representation. |pixel_width| and |pixel_height| are the representation
-    // size in pixel coordinates. Returns true (1) on success.
-    ///
-    int function (
-        _cef_image_t* self,
-        float scale_factor,
-        float* actual_scale_factor,
-        int* pixel_width,
-        int* pixel_height) nothrow get_representation_info;
-
-    ///
-    // Returns the bitmap representation that most closely matches |scale_factor|.
-    // Only 32-bit RGBA/BGRA formats are supported. |color_type| and |alpha_type|
-    // values specify the desired output pixel format. |pixel_width| and
-    // |pixel_height| are the output representation size in pixel coordinates.
-    // Returns a cef_binary_value_t containing the pixel data on success or NULL
-    // on failure.
-    ///
-    _cef_binary_value_t* function (
-        _cef_image_t* self,
-        float scale_factor,
-        cef_color_type_t color_type,
-        cef_alpha_type_t alpha_type,
-        int* pixel_width,
-        int* pixel_height) nothrow get_as_bitmap;
-
-    ///
-    // Returns the PNG representation that most closely matches |scale_factor|. If
-    // |with_transparency| is true (1) any alpha transparency in the image will be
-    // represented in the resulting PNG data. |pixel_width| and |pixel_height| are
-    // the output representation size in pixel coordinates. Returns a
-    // cef_binary_value_t containing the PNG image data on success or NULL on
-    // failure.
-    ///
-    _cef_binary_value_t* function (
-        _cef_image_t* self,
-        float scale_factor,
-        int with_transparency,
-        int* pixel_width,
-        int* pixel_height) nothrow get_as_png;
-
-    ///
-    // Returns the JPEG representation that most closely matches |scale_factor|.
-    // |quality| determines the compression level with 0 == lowest and 100 ==
-    // highest. The JPEG format does not support alpha transparency and the alpha
-    // channel, if any, will be discarded. |pixel_width| and |pixel_height| are
-    // the output representation size in pixel coordinates. Returns a
-    // cef_binary_value_t containing the JPEG image data on success or NULL on
-    // failure.
-    ///
-    _cef_binary_value_t* function (
-        _cef_image_t* self,
-        float scale_factor,
-        int quality,
-        int* pixel_width,
-        int* pixel_height) nothrow get_as_jpeg;
-}
-
-alias cef_image_t = _cef_image_t;
-
-///
-// Create a new cef_image_t. It will initially be NULL. Use the Add*() functions
-// to add representations at different scale factors.
-///
-cef_image_t* cef_image_create ();
-
-// CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=e68da1a5db612699b7b727edea2bb629f5d67103$
-//
-
-extern (C):
-
-///
-// Callback structure used for asynchronous continuation of JavaScript dialog
-// requests.
-///
-struct _cef_jsdialog_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Continue the JS dialog request. Set |success| to true (1) if the OK button
-    // was pressed. The |user_input| value should be specified for prompt dialogs.
-    ///
-    void function (
-        _cef_jsdialog_callback_t* self,
-        int success,
-        const(cef_string_t)* user_input) nothrow cont;
-}
-
-alias cef_jsdialog_callback_t = _cef_jsdialog_callback_t;
-
-///
-// Implement this structure to handle events related to JavaScript dialogs. The
-// functions of this structure will be called on the UI thread.
-///
-struct _cef_jsdialog_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called to run a JavaScript dialog. If |origin_url| is non-NULL it can be
-    // passed to the CefFormatUrlForSecurityDisplay function to retrieve a secure
-    // and user-friendly display string. The |default_prompt_text| value will be
-    // specified for prompt dialogs only. Set |suppress_message| to true (1) and
-    // return false (0) to suppress the message (suppressing messages is
-    // preferable to immediately executing the callback as this is used to detect
-    // presumably malicious behavior like spamming alert messages in
-    // onbeforeunload). Set |suppress_message| to false (0) and return false (0)
-    // to use the default implementation (the default implementation will show one
-    // modal dialog at a time and suppress any additional dialog requests until
-    // the displayed dialog is dismissed). Return true (1) if the application will
-    // use a custom dialog or if the callback has been executed immediately.
-    // Custom dialogs may be either modal or modeless. If a custom dialog is used
-    // the application must execute |callback| once the custom dialog is
-    // dismissed.
-    ///
-    int function (
-        _cef_jsdialog_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* origin_url,
-        cef_jsdialog_type_t dialog_type,
-        const(cef_string_t)* message_text,
-        const(cef_string_t)* default_prompt_text,
-        _cef_jsdialog_callback_t* callback,
-        int* suppress_message) nothrow on_jsdialog;
-
-    ///
-    // Called to run a dialog asking the user if they want to leave a page. Return
-    // false (0) to use the default dialog implementation. Return true (1) if the
-    // application will use a custom dialog or if the callback has been executed
-    // immediately. Custom dialogs may be either modal or modeless. If a custom
-    // dialog is used the application must execute |callback| once the custom
-    // dialog is dismissed.
-    ///
-    int function (
-        _cef_jsdialog_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* message_text,
-        int is_reload,
-        _cef_jsdialog_callback_t* callback) nothrow on_before_unload_dialog;
-
-    ///
-    // Called to cancel any pending dialogs and reset any saved dialog state. Will
-    // be called due to events like page navigation irregardless of whether any
-    // dialogs are currently pending.
-    ///
-    void function (
-        _cef_jsdialog_handler_t* self,
-        _cef_browser_t* browser) nothrow on_reset_dialog_state;
-
-    ///
-    // Called when the default implementation dialog is closed.
-    ///
-    void function (
-        _cef_jsdialog_handler_t* self,
-        _cef_browser_t* browser) nothrow on_dialog_closed;
-}
-
-alias cef_jsdialog_handler_t = _cef_jsdialog_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=70108de432674485dee079e541e0dacd6a437961$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle events related to keyboard input. The
-// functions of this structure will be called on the UI thread.
-///
-struct _cef_keyboard_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called before a keyboard event is sent to the renderer. |event| contains
-    // information about the keyboard event. |os_event| is the operating system
-    // event message, if any. Return true (1) if the event was handled or false
-    // (0) otherwise. If the event will be handled in on_key_event() as a keyboard
-    // shortcut set |is_keyboard_shortcut| to true (1) and return false (0).
-    ///
-    int function (
-        _cef_keyboard_handler_t* self,
-        _cef_browser_t* browser,
-        const(_cef_key_event_t)* event,
-        OS_EVENT* os_event,
-        int* is_keyboard_shortcut) nothrow on_pre_key_event;
-
-    ///
-    // Called after the renderer and JavaScript in the page has had a chance to
-    // handle the event. |event| contains information about the keyboard event.
-    // |os_event| is the operating system event message, if any. Return true (1)
-    // if the keyboard event was handled or false (0) otherwise.
-    ///
-    int function (
-        _cef_keyboard_handler_t* self,
-        _cef_browser_t* browser,
-        const(_cef_key_event_t)* event,
-        OS_EVENT* os_event) nothrow on_key_event;
-}
-
-alias cef_keyboard_handler_t = _cef_keyboard_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=d6e91d55d41f729dca94ba5766f57849f29d0796$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle events related to browser life span. The
-// functions of this structure will be called on the UI thread unless otherwise
-// indicated.
-///
-struct _cef_life_span_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called on the UI thread before a new popup browser is created. The
-    // |browser| and |frame| values represent the source of the popup request. The
-    // |target_url| and |target_frame_name| values indicate where the popup
-    // browser should navigate and may be NULL if not specified with the request.
-    // The |target_disposition| value indicates where the user intended to open
-    // the popup (e.g. current tab, new tab, etc). The |user_gesture| value will
-    // be true (1) if the popup was opened via explicit user gesture (e.g.
-    // clicking a link) or false (0) if the popup opened automatically (e.g. via
-    // the DomContentLoaded event). The |popupFeatures| structure contains
-    // additional information about the requested popup window. To allow creation
-    // of the popup browser optionally modify |windowInfo|, |client|, |settings|
-    // and |no_javascript_access| and return false (0). To cancel creation of the
-    // popup browser return true (1). The |client| and |settings| values will
-    // default to the source browser's values. If the |no_javascript_access| value
-    // is set to false (0) the new browser will not be scriptable and may not be
-    // hosted in the same renderer process as the source browser. Any
-    // modifications to |windowInfo| will be ignored if the parent browser is
-    // wrapped in a cef_browser_view_t. Popup browser creation will be canceled if
-    // the parent browser is destroyed before the popup browser creation completes
-    // (indicated by a call to OnAfterCreated for the popup browser). The
-    // |extra_info| parameter provides an opportunity to specify extra information
-    // specific to the created popup browser that will be passed to
-    // cef_render_process_handler_t::on_browser_created() in the render process.
-    ///
-    int function (
-        _cef_life_span_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        const(cef_string_t)* target_url,
-        const(cef_string_t)* target_frame_name,
-        cef_window_open_disposition_t target_disposition,
-        int user_gesture,
-        const(_cef_popup_features_t)* popupFeatures,
-        _cef_window_info_t* windowInfo,
-        _cef_client_t** client,
-        _cef_browser_settings_t* settings,
-        _cef_dictionary_value_t** extra_info,
-        int* no_javascript_access) nothrow on_before_popup;
-
-    ///
-    // Called after a new browser is created. This callback will be the first
-    // notification that references |browser|.
-    ///
-    void function (
-        _cef_life_span_handler_t* self,
-        _cef_browser_t* browser) nothrow on_after_created;
-
-    ///
-    // Called when a browser has recieved a request to close. This may result
-    // directly from a call to cef_browser_host_t::*close_browser() or indirectly
-    // if the browser is parented to a top-level window created by CEF and the
-    // user attempts to close that window (by clicking the 'X', for example). The
-    // do_close() function will be called after the JavaScript 'onunload' event
-    // has been fired.
-    //
-    // An application should handle top-level owner window close notifications by
-    // calling cef_browser_host_t::try_close_browser() or
-    // cef_browser_host_t::CloseBrowser(false (0)) instead of allowing the window
-    // to close immediately (see the examples below). This gives CEF an
-    // opportunity to process the 'onbeforeunload' event and optionally cancel the
-    // close before do_close() is called.
-    //
-    // When windowed rendering is enabled CEF will internally create a window or
-    // view to host the browser. In that case returning false (0) from do_close()
-    // will send the standard close notification to the browser's top-level owner
-    // window (e.g. WM_CLOSE on Windows, performClose: on OS X, "delete_event" on
-    // Linux or cef_window_delegate_t::can_close() callback from Views). If the
-    // browser's host window/view has already been destroyed (via view hierarchy
-    // tear-down, for example) then do_close() will not be called for that browser
-    // since is no longer possible to cancel the close.
-    //
-    // When windowed rendering is disabled returning false (0) from do_close()
-    // will cause the browser object to be destroyed immediately.
-    //
-    // If the browser's top-level owner window requires a non-standard close
-    // notification then send that notification from do_close() and return true
-    // (1).
-    //
-    // The cef_life_span_handler_t::on_before_close() function will be called
-    // after do_close() (if do_close() is called) and immediately before the
-    // browser object is destroyed. The application should only exit after
-    // on_before_close() has been called for all existing browsers.
-    //
-    // The below examples describe what should happen during window close when the
-    // browser is parented to an application-provided top-level window.
-    //
-    // Example 1: Using cef_browser_host_t::try_close_browser(). This is
-    // recommended for clients using standard close handling and windows created
-    // on the browser process UI thread. 1.  User clicks the window close button
-    // which sends a close notification to
-    //     the application's top-level window.
-    // 2.  Application's top-level window receives the close notification and
-    //     calls TryCloseBrowser() (which internally calls CloseBrowser(false)).
-    //     TryCloseBrowser() returns false so the client cancels the window close.
-    // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
-    //     confirmation dialog (which can be overridden via
-    //     CefJSDialogHandler::OnBeforeUnloadDialog()).
-    // 4.  User approves the close. 5.  JavaScript 'onunload' handler executes. 6.
-    // CEF sends a close notification to the application's top-level window
-    //     (because DoClose() returned false by default).
-    // 7.  Application's top-level window receives the close notification and
-    //     calls TryCloseBrowser(). TryCloseBrowser() returns true so the client
-    //     allows the window close.
-    // 8.  Application's top-level window is destroyed. 9.  Application's
-    // on_before_close() handler is called and the browser object
-    //     is destroyed.
-    // 10. Application exits by calling cef_quit_message_loop() if no other
-    // browsers
-    //     exist.
-    //
-    // Example 2: Using cef_browser_host_t::CloseBrowser(false (0)) and
-    // implementing the do_close() callback. This is recommended for clients using
-    // non-standard close handling or windows that were not created on the browser
-    // process UI thread. 1.  User clicks the window close button which sends a
-    // close notification to
-    //     the application's top-level window.
-    // 2.  Application's top-level window receives the close notification and:
-    //     A. Calls CefBrowserHost::CloseBrowser(false).
-    //     B. Cancels the window close.
-    // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
-    //     confirmation dialog (which can be overridden via
-    //     CefJSDialogHandler::OnBeforeUnloadDialog()).
-    // 4.  User approves the close. 5.  JavaScript 'onunload' handler executes. 6.
-    // Application's do_close() handler is called. Application will:
-    //     A. Set a flag to indicate that the next close attempt will be allowed.
-    //     B. Return false.
-    // 7.  CEF sends an close notification to the application's top-level window.
-    // 8.  Application's top-level window receives the close notification and
-    //     allows the window to close based on the flag from #6B.
-    // 9.  Application's top-level window is destroyed. 10. Application's
-    // on_before_close() handler is called and the browser object
-    //     is destroyed.
-    // 11. Application exits by calling cef_quit_message_loop() if no other
-    // browsers
-    //     exist.
-    ///
-    int function (
-        _cef_life_span_handler_t* self,
-        _cef_browser_t* browser) nothrow do_close;
-
-    ///
-    // Called just before a browser is destroyed. Release all references to the
-    // browser object and do not attempt to execute any functions on the browser
-    // object (other than GetIdentifier or IsSame) after this callback returns.
-    // This callback will be the last notification that references |browser| on
-    // the UI thread. Any in-progress network requests associated with |browser|
-    // will be aborted when the browser is destroyed, and
-    // cef_resource_request_handler_t callbacks related to those requests may
-    // still arrive on the IO thread after this function is called. See do_close()
-    // documentation for additional usage information.
-    ///
-    void function (
-        _cef_life_span_handler_t* self,
-        _cef_browser_t* browser) nothrow on_before_close;
-}
-
-alias cef_life_span_handler_t = _cef_life_span_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=fa3cb1461b9d363c6c7d961f9e291c2fe736170e$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle events related to browser load status. The
-// functions of this structure will be called on the browser process UI thread
-// or render process main thread (TID_RENDERER).
-///
-struct _cef_load_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called when the loading state has changed. This callback will be executed
-    // twice -- once when loading is initiated either programmatically or by user
-    // action, and once when loading is terminated due to completion, cancellation
-    // of failure. It will be called before any calls to OnLoadStart and after all
-    // calls to OnLoadError and/or OnLoadEnd.
-    ///
-    void function (
-        _cef_load_handler_t* self,
-        _cef_browser_t* browser,
-        int isLoading,
-        int canGoBack,
-        int canGoForward) nothrow on_loading_state_change;
-
-    ///
-    // Called after a navigation has been committed and before the browser begins
-    // loading contents in the frame. The |frame| value will never be NULL -- call
-    // the is_main() function to check if this frame is the main frame.
-    // |transition_type| provides information about the source of the navigation
-    // and an accurate value is only available in the browser process. Multiple
-    // frames may be loading at the same time. Sub-frames may start or continue
-    // loading after the main frame load has ended. This function will not be
-    // called for same page navigations (fragments, history state, etc.) or for
-    // navigations that fail or are canceled before commit. For notification of
-    // overall browser load status use OnLoadingStateChange instead.
-    ///
-    void function (
-        _cef_load_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        cef_transition_type_t transition_type) nothrow on_load_start;
-
-    ///
-    // Called when the browser is done loading a frame. The |frame| value will
-    // never be NULL -- call the is_main() function to check if this frame is the
-    // main frame. Multiple frames may be loading at the same time. Sub-frames may
-    // start or continue loading after the main frame load has ended. This
-    // function will not be called for same page navigations (fragments, history
-    // state, etc.) or for navigations that fail or are canceled before commit.
-    // For notification of overall browser load status use OnLoadingStateChange
-    // instead.
-    ///
-    void function (
-        _cef_load_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        int httpStatusCode) nothrow on_load_end;
-
-    ///
-    // Called when a navigation fails or is canceled. This function may be called
-    // by itself if before commit or in combination with OnLoadStart/OnLoadEnd if
-    // after commit. |errorCode| is the error code number, |errorText| is the
-    // error text and |failedUrl| is the URL that failed to load. See
-    // net\base\net_error_list.h for complete descriptions of the error codes.
-    ///
-    void function (
-        _cef_load_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        cef_errorcode_t errorCode,
-        const(cef_string_t)* errorText,
-        const(cef_string_t)* failedUrl) nothrow on_load_error;
-}
-
-alias cef_load_handler_t = _cef_load_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=4f4a0d76efaf87055ebf5e784f5d1b69fafdabc2$
-//
-
-extern (C):
-
-///
-// Supports discovery of and communication with media devices on the local
-// network via the Cast and DIAL protocols. The functions of this structure may
-// be called on any browser process thread unless otherwise indicated.
-///
-struct _cef_media_router_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Add an observer for MediaRouter events. The observer will remain registered
-    // until the returned Registration object is destroyed.
-    ///
-    _cef_registration_t* function (
-        _cef_media_router_t* self,
-        _cef_media_observer_t* observer) nothrow add_observer;
-
-    ///
-    // Returns a MediaSource object for the specified media source URN. Supported
-    // URN schemes include "cast:" and "dial:", and will be already known by the
-    // client application (e.g. "cast:<appId>?clientId=<clientId>").
-    ///
-    _cef_media_source_t* function (
-        _cef_media_router_t* self,
-        const(cef_string_t)* urn) nothrow get_source;
-
-    ///
-    // Trigger an asynchronous call to cef_media_observer_t::OnSinks on all
-    // registered observers.
-    ///
-    void function (_cef_media_router_t* self) nothrow notify_current_sinks;
-
-    ///
-    // Create a new route between |source| and |sink|. Source and sink must be
-    // valid, compatible (as reported by cef_media_sink_t::IsCompatibleWith), and
-    // a route between them must not already exist. |callback| will be executed on
-    // success or failure. If route creation succeeds it will also trigger an
-    // asynchronous call to cef_media_observer_t::OnRoutes on all registered
-    // observers.
-    ///
-    void function (
-        _cef_media_router_t* self,
-        _cef_media_source_t* source,
-        _cef_media_sink_t* sink,
-        _cef_media_route_create_callback_t* callback) nothrow create_route;
-
-    ///
-    // Trigger an asynchronous call to cef_media_observer_t::OnRoutes on all
-    // registered observers.
-    ///
-    void function (_cef_media_router_t* self) nothrow notify_current_routes;
-}
-
-alias cef_media_router_t = _cef_media_router_t;
-
-///
-// Returns the MediaRouter object associated with the global request context.
-// Equivalent to calling cef_request_context_t::cef_request_context_get_global_c
-// ontext()->get_media_router().
-///
-cef_media_router_t* cef_media_router_get_global ();
-
-///
-// Implemented by the client to observe MediaRouter events and registered via
-// cef_media_router_t::AddObserver. The functions of this structure will be
-// called on the browser process UI thread.
-///
-struct _cef_media_observer_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // The list of available media sinks has changed or
-    // cef_media_router_t::NotifyCurrentSinks was called.
-    ///
-    void function (
-        _cef_media_observer_t* self,
-        size_t sinksCount,
-        _cef_media_sink_t** sinks) nothrow on_sinks;
-
-    ///
-    // The list of available media routes has changed or
-    // cef_media_router_t::NotifyCurrentRoutes was called.
-    ///
-    void function (
-        _cef_media_observer_t* self,
-        size_t routesCount,
-        _cef_media_route_t** routes) nothrow on_routes;
-
-    ///
-    // The connection state of |route| has changed.
-    ///
-    void function (
-        _cef_media_observer_t* self,
-        _cef_media_route_t* route,
-        cef_media_route_connection_state_t state) nothrow on_route_state_changed;
-
-    ///
-    // A message was recieved over |route|. |message| is only valid for the scope
-    // of this callback and should be copied if necessary.
-    ///
-    void function (
-        _cef_media_observer_t* self,
-        _cef_media_route_t* route,
-        const(void)* message,
-        size_t message_size) nothrow on_route_message_received;
-}
-
-alias cef_media_observer_t = _cef_media_observer_t;
-
-///
-// Represents the route between a media source and sink. Instances of this
-// object are created via cef_media_router_t::CreateRoute and retrieved via
-// cef_media_observer_t::OnRoutes. Contains the status and metadata of a routing
-// operation. The functions of this structure may be called on any browser
-// process thread unless otherwise indicated.
-///
-struct _cef_media_route_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the ID for this route.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_media_route_t* self) nothrow get_id;
-
-    ///
-    // Returns the source associated with this route.
-    ///
-    _cef_media_source_t* function (_cef_media_route_t* self) nothrow get_source;
-
-    ///
-    // Returns the sink associated with this route.
-    ///
-    _cef_media_sink_t* function (_cef_media_route_t* self) nothrow get_sink;
-
-    ///
-    // Send a message over this route. |message| will be copied if necessary.
-    ///
-    void function (
-        _cef_media_route_t* self,
-        const(void)* message,
-        size_t message_size) nothrow send_route_message;
-
-    ///
-    // Terminate this route. Will result in an asynchronous call to
-    // cef_media_observer_t::OnRoutes on all registered observers.
-    ///
-    void function (_cef_media_route_t* self) nothrow terminate;
-}
-
-alias cef_media_route_t = _cef_media_route_t;
-
-///
-// Callback structure for cef_media_router_t::CreateRoute. The functions of this
-// structure will be called on the browser process UI thread.
-///
-struct _cef_media_route_create_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be executed when the route creation has finished. |result|
-    // will be CEF_MRCR_OK if the route creation succeeded. |error| will be a
-    // description of the error if the route creation failed. |route| is the
-    // resulting route, or NULL if the route creation failed.
-    ///
-    void function (
-        _cef_media_route_create_callback_t* self,
-        cef_media_route_create_result_t result,
-        const(cef_string_t)* error,
-        _cef_media_route_t* route) nothrow on_media_route_create_finished;
-}
-
-alias cef_media_route_create_callback_t = _cef_media_route_create_callback_t;
-
-///
-// Represents a sink to which media can be routed. Instances of this object are
-// retrieved via cef_media_observer_t::OnSinks. The functions of this structure
-// may be called on any browser process thread unless otherwise indicated.
-///
-struct _cef_media_sink_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the ID for this sink.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_media_sink_t* self) nothrow get_id;
-
-    ///
-    // Returns the name of this sink.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_media_sink_t* self) nothrow get_name;
-
-    ///
-    // Returns the description of this sink.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_media_sink_t* self) nothrow get_description;
-
-    ///
-    // Returns the icon type for this sink.
-    ///
-    cef_media_sink_icon_type_t function (
-        _cef_media_sink_t* self) nothrow get_icon_type;
-
-    ///
-    // Asynchronously retrieves device info.
-    ///
-    void function (
-        _cef_media_sink_t* self,
-        _cef_media_sink_device_info_callback_t* callback) nothrow get_device_info;
-
-    ///
-    // Returns true (1) if this sink accepts content via Cast.
-    ///
-    int function (_cef_media_sink_t* self) nothrow is_cast_sink;
-
-    ///
-    // Returns true (1) if this sink accepts content via DIAL.
-    ///
-    int function (_cef_media_sink_t* self) nothrow is_dial_sink;
-
-    ///
-    // Returns true (1) if this sink is compatible with |source|.
-    ///
-    int function (
-        _cef_media_sink_t* self,
-        _cef_media_source_t* source) nothrow is_compatible_with;
-}
-
-alias cef_media_sink_t = _cef_media_sink_t;
-
-///
-// Callback structure for cef_media_sink_t::GetDeviceInfo. The functions of this
-// structure will be called on the browser process UI thread.
-///
-struct _cef_media_sink_device_info_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be executed asyncronously once device information has been
-    // retrieved.
-    ///
-    void function (
-        _cef_media_sink_device_info_callback_t* self,
-        const(_cef_media_sink_device_info_t)* device_info) nothrow on_media_sink_device_info;
-}
-
-alias cef_media_sink_device_info_callback_t = _cef_media_sink_device_info_callback_t;
-
-///
-// Represents a source from which media can be routed. Instances of this object
-// are retrieved via cef_media_router_t::GetSource. The functions of this
-// structure may be called on any browser process thread unless otherwise
-// indicated.
-///
-struct _cef_media_source_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the ID (media source URN or URL) for this source.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_media_source_t* self) nothrow get_id;
-
-    ///
-    // Returns true (1) if this source outputs its content via Cast.
-    ///
-    int function (_cef_media_source_t* self) nothrow is_cast_source;
-
-    ///
-    // Returns true (1) if this source outputs its content via DIAL.
-    ///
-    int function (_cef_media_source_t* self) nothrow is_dial_source;
-}
-
-alias cef_media_source_t = _cef_media_source_t;
-
-// CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=cce24dba079162b10f359769eea176c4009b5ce5$
-//
-
-extern (C):
-
-///
-// Supports creation and modification of menus. See cef_menu_id_t for the
-// command ids that have default implementations. All user-defined command ids
-// should be between MENU_ID_USER_FIRST and MENU_ID_USER_LAST. The functions of
-// this structure can only be accessed on the browser process the UI thread.
-///
-struct _cef_menu_model_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this menu is a submenu.
-    ///
-    int function (_cef_menu_model_t* self) nothrow is_sub_menu;
-
-    ///
-    // Clears the menu. Returns true (1) on success.
-    ///
-    int function (_cef_menu_model_t* self) nothrow clear;
-
-    ///
-    // Returns the number of items in this menu.
-    ///
-    int function (_cef_menu_model_t* self) nothrow get_count;
-
-    ///
-    // Add a separator to the menu. Returns true (1) on success.
-    ///
-    int function (_cef_menu_model_t* self) nothrow add_separator;
-
-    ///
-    // Add an item to the menu. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        const(cef_string_t)* label) nothrow add_item;
-
-    ///
-    // Add a check item to the menu. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        const(cef_string_t)* label) nothrow add_check_item;
-
-    ///
-    // Add a radio item to the menu. Only a single item with the specified
-    // |group_id| can be checked at a time. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        const(cef_string_t)* label,
-        int group_id) nothrow add_radio_item;
-
-    ///
-    // Add a sub-menu to the menu. The new sub-menu is returned.
-    ///
-    _cef_menu_model_t* function (
-        _cef_menu_model_t* self,
-        int command_id,
-        const(cef_string_t)* label) nothrow add_sub_menu;
-
-    ///
-    // Insert a separator in the menu at the specified |index|. Returns true (1)
-    // on success.
-    ///
-    int function (_cef_menu_model_t* self, int index) nothrow insert_separator_at;
-
-    ///
-    // Insert an item in the menu at the specified |index|. Returns true (1) on
-    // success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int command_id,
-        const(cef_string_t)* label) nothrow insert_item_at;
-
-    ///
-    // Insert a check item in the menu at the specified |index|. Returns true (1)
-    // on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int command_id,
-        const(cef_string_t)* label) nothrow insert_check_item_at;
-
-    ///
-    // Insert a radio item in the menu at the specified |index|. Only a single
-    // item with the specified |group_id| can be checked at a time. Returns true
-    // (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int command_id,
-        const(cef_string_t)* label,
-        int group_id) nothrow insert_radio_item_at;
-
-    ///
-    // Insert a sub-menu in the menu at the specified |index|. The new sub-menu is
-    // returned.
-    ///
-    _cef_menu_model_t* function (
-        _cef_menu_model_t* self,
-        int index,
-        int command_id,
-        const(cef_string_t)* label) nothrow insert_sub_menu_at;
-
-    ///
-    // Removes the item with the specified |command_id|. Returns true (1) on
-    // success.
-    ///
-    int function (_cef_menu_model_t* self, int command_id) nothrow remove;
-
-    ///
-    // Removes the item at the specified |index|. Returns true (1) on success.
-    ///
-    int function (_cef_menu_model_t* self, int index) nothrow remove_at;
-
-    ///
-    // Returns the index associated with the specified |command_id| or -1 if not
-    // found due to the command id not existing in the menu.
-    ///
-    int function (_cef_menu_model_t* self, int command_id) nothrow get_index_of;
-
-    ///
-    // Returns the command id at the specified |index| or -1 if not found due to
-    // invalid range or the index being a separator.
-    ///
-    int function (_cef_menu_model_t* self, int index) nothrow get_command_id_at;
-
-    ///
-    // Sets the command id at the specified |index|. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int command_id) nothrow set_command_id_at;
-
-    ///
-    // Returns the label for the specified |command_id| or NULL if not found.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_menu_model_t* self,
-        int command_id) nothrow get_label;
-
-    ///
-    // Returns the label at the specified |index| or NULL if not found due to
-    // invalid range or the index being a separator.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_menu_model_t* self,
-        int index) nothrow get_label_at;
-
-    ///
-    // Sets the label for the specified |command_id|. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        const(cef_string_t)* label) nothrow set_label;
-
-    ///
-    // Set the label at the specified |index|. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        const(cef_string_t)* label) nothrow set_label_at;
-
-    ///
-    // Returns the item type for the specified |command_id|.
-    ///
-    cef_menu_item_type_t function (
-        _cef_menu_model_t* self,
-        int command_id) nothrow get_type;
-
-    ///
-    // Returns the item type at the specified |index|.
-    ///
-    cef_menu_item_type_t function (
-        _cef_menu_model_t* self,
-        int index) nothrow get_type_at;
-
-    ///
-    // Returns the group id for the specified |command_id| or -1 if invalid.
-    ///
-    int function (_cef_menu_model_t* self, int command_id) nothrow get_group_id;
-
-    ///
-    // Returns the group id at the specified |index| or -1 if invalid.
-    ///
-    int function (_cef_menu_model_t* self, int index) nothrow get_group_id_at;
-
-    ///
-    // Sets the group id for the specified |command_id|. Returns true (1) on
-    // success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        int group_id) nothrow set_group_id;
-
-    ///
-    // Sets the group id at the specified |index|. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int group_id) nothrow set_group_id_at;
-
-    ///
-    // Returns the submenu for the specified |command_id| or NULL if invalid.
-    ///
-    _cef_menu_model_t* function (
-        _cef_menu_model_t* self,
-        int command_id) nothrow get_sub_menu;
-
-    ///
-    // Returns the submenu at the specified |index| or NULL if invalid.
-    ///
-    _cef_menu_model_t* function (
-        _cef_menu_model_t* self,
-        int index) nothrow get_sub_menu_at;
-
-    ///
-    // Returns true (1) if the specified |command_id| is visible.
-    ///
-    int function (_cef_menu_model_t* self, int command_id) nothrow is_visible;
-
-    ///
-    // Returns true (1) if the specified |index| is visible.
-    ///
-    int function (_cef_menu_model_t* self, int index) nothrow is_visible_at;
-
-    ///
-    // Change the visibility of the specified |command_id|. Returns true (1) on
-    // success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        int visible) nothrow set_visible;
-
-    ///
-    // Change the visibility at the specified |index|. Returns true (1) on
-    // success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int visible) nothrow set_visible_at;
-
-    ///
-    // Returns true (1) if the specified |command_id| is enabled.
-    ///
-    int function (_cef_menu_model_t* self, int command_id) nothrow is_enabled;
-
-    ///
-    // Returns true (1) if the specified |index| is enabled.
-    ///
-    int function (_cef_menu_model_t* self, int index) nothrow is_enabled_at;
-
-    ///
-    // Change the enabled status of the specified |command_id|. Returns true (1)
-    // on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        int enabled) nothrow set_enabled;
-
-    ///
-    // Change the enabled status at the specified |index|. Returns true (1) on
-    // success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int enabled) nothrow set_enabled_at;
-
-    ///
-    // Returns true (1) if the specified |command_id| is checked. Only applies to
-    // check and radio items.
-    ///
-    int function (_cef_menu_model_t* self, int command_id) nothrow is_checked;
-
-    ///
-    // Returns true (1) if the specified |index| is checked. Only applies to check
-    // and radio items.
-    ///
-    int function (_cef_menu_model_t* self, int index) nothrow is_checked_at;
-
-    ///
-    // Check the specified |command_id|. Only applies to check and radio items.
-    // Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        int checked) nothrow set_checked;
-
-    ///
-    // Check the specified |index|. Only applies to check and radio items. Returns
-    // true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int checked) nothrow set_checked_at;
-
-    ///
-    // Returns true (1) if the specified |command_id| has a keyboard accelerator
-    // assigned.
-    ///
-    int function (_cef_menu_model_t* self, int command_id) nothrow has_accelerator;
-
-    ///
-    // Returns true (1) if the specified |index| has a keyboard accelerator
-    // assigned.
-    ///
-    int function (_cef_menu_model_t* self, int index) nothrow has_accelerator_at;
-
-    ///
-    // Set the keyboard accelerator for the specified |command_id|. |key_code| can
-    // be any virtual key or character value. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        int key_code,
-        int shift_pressed,
-        int ctrl_pressed,
-        int alt_pressed) nothrow set_accelerator;
-
-    ///
-    // Set the keyboard accelerator at the specified |index|. |key_code| can be
-    // any virtual key or character value. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int key_code,
-        int shift_pressed,
-        int ctrl_pressed,
-        int alt_pressed) nothrow set_accelerator_at;
-
-    ///
-    // Remove the keyboard accelerator for the specified |command_id|. Returns
-    // true (1) on success.
-    ///
-    int function (_cef_menu_model_t* self, int command_id) nothrow remove_accelerator;
-
-    ///
-    // Remove the keyboard accelerator at the specified |index|. Returns true (1)
-    // on success.
-    ///
-    int function (_cef_menu_model_t* self, int index) nothrow remove_accelerator_at;
-
-    ///
-    // Retrieves the keyboard accelerator for the specified |command_id|. Returns
-    // true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        int* key_code,
-        int* shift_pressed,
-        int* ctrl_pressed,
-        int* alt_pressed) nothrow get_accelerator;
-
-    ///
-    // Retrieves the keyboard accelerator for the specified |index|. Returns true
-    // (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        int* key_code,
-        int* shift_pressed,
-        int* ctrl_pressed,
-        int* alt_pressed) nothrow get_accelerator_at;
-
-    ///
-    // Set the explicit color for |command_id| and |color_type| to |color|.
-    // Specify a |color| value of 0 to remove the explicit color. If no explicit
-    // color or default color is set for |color_type| then the system color will
-    // be used. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        cef_menu_color_type_t color_type,
-        cef_color_t color) nothrow set_color;
-
-    ///
-    // Set the explicit color for |command_id| and |index| to |color|. Specify a
-    // |color| value of 0 to remove the explicit color. Specify an |index| value
-    // of -1 to set the default color for items that do not have an explicit color
-    // set. If no explicit color or default color is set for |color_type| then the
-    // system color will be used. Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        cef_menu_color_type_t color_type,
-        cef_color_t color) nothrow set_color_at;
-
-    ///
-    // Returns in |color| the color that was explicitly set for |command_id| and
-    // |color_type|. If a color was not set then 0 will be returned in |color|.
-    // Returns true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        cef_menu_color_type_t color_type,
-        cef_color_t* color) nothrow get_color;
-
-    ///
-    // Returns in |color| the color that was explicitly set for |command_id| and
-    // |color_type|. Specify an |index| value of -1 to return the default color in
-    // |color|. If a color was not set then 0 will be returned in |color|. Returns
-    // true (1) on success.
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        cef_menu_color_type_t color_type,
-        cef_color_t* color) nothrow get_color_at;
-
-    ///
-    // Sets the font list for the specified |command_id|. If |font_list| is NULL
-    // the system font will be used. Returns true (1) on success. The format is
-    // "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where: - FONT_FAMILY_LIST is a comma-
-    // separated list of font family names, - STYLES is an optional space-
-    // separated list of style names (case-sensitive
-    //   "Bold" and "Italic" are supported), and
-    // - SIZE is an integer font size in pixels with the suffix "px".
-    //
-    // Here are examples of valid font description strings: - "Arial, Helvetica,
-    // Bold Italic 14px" - "Arial, 14px"
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int command_id,
-        const(cef_string_t)* font_list) nothrow set_font_list;
-
-    ///
-    // Sets the font list for the specified |index|. Specify an |index| value of
-    // -1 to set the default font. If |font_list| is NULL the system font will be
-    // used. Returns true (1) on success. The format is
-    // "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where: - FONT_FAMILY_LIST is a comma-
-    // separated list of font family names, - STYLES is an optional space-
-    // separated list of style names (case-sensitive
-    //   "Bold" and "Italic" are supported), and
-    // - SIZE is an integer font size in pixels with the suffix "px".
-    //
-    // Here are examples of valid font description strings: - "Arial, Helvetica,
-    // Bold Italic 14px" - "Arial, 14px"
-    ///
-    int function (
-        _cef_menu_model_t* self,
-        int index,
-        const(cef_string_t)* font_list) nothrow set_font_list_at;
-}
-
-alias cef_menu_model_t = _cef_menu_model_t;
-
-///
-// Create a new MenuModel with the specified |delegate|.
-///
-cef_menu_model_t* cef_menu_model_create (_cef_menu_model_delegate_t* delegate_);
-
-// CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=071ec8a0e17d3b33acbf36c7ccc26d0995657cf3$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle menu model events. The functions of this
-// structure will be called on the browser process UI thread unless otherwise
-// indicated.
-///
-struct _cef_menu_model_delegate_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Perform the action associated with the specified |command_id| and optional
-    // |event_flags|.
-    ///
-    void function (
-        _cef_menu_model_delegate_t* self,
-        _cef_menu_model_t* menu_model,
-        int command_id,
-        cef_event_flags_t event_flags) nothrow execute_command;
-
-    ///
-    // Called when the user moves the mouse outside the menu and over the owning
-    // window.
-    ///
-    void function (
-        _cef_menu_model_delegate_t* self,
-        _cef_menu_model_t* menu_model,
-        const(cef_point_t)* screen_point) nothrow mouse_outside_menu;
-
-    ///
-    // Called on unhandled open submenu keyboard commands. |is_rtl| will be true
-    // (1) if the menu is displaying a right-to-left language.
-    ///
-    void function (
-        _cef_menu_model_delegate_t* self,
-        _cef_menu_model_t* menu_model,
-        int is_rtl) nothrow unhandled_open_submenu;
-
-    ///
-    // Called on unhandled close submenu keyboard commands. |is_rtl| will be true
-    // (1) if the menu is displaying a right-to-left language.
-    ///
-    void function (
-        _cef_menu_model_delegate_t* self,
-        _cef_menu_model_t* menu_model,
-        int is_rtl) nothrow unhandled_close_submenu;
-
-    ///
-    // The menu is about to show.
-    ///
-    void function (
-        _cef_menu_model_delegate_t* self,
-        _cef_menu_model_t* menu_model) nothrow menu_will_show;
-
-    ///
-    // The menu has closed.
-    ///
-    void function (
-        _cef_menu_model_delegate_t* self,
-        _cef_menu_model_t* menu_model) nothrow menu_closed;
-
-    ///
-    // Optionally modify a menu item label. Return true (1) if |label| was
-    // modified.
-    ///
-    int function (
-        _cef_menu_model_delegate_t* self,
-        _cef_menu_model_t* menu_model,
-        cef_string_t* label) nothrow format_label;
-}
-
-alias cef_menu_model_delegate_t = _cef_menu_model_delegate_t;
-
-// CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=c6252024911652a4881d753aeeeb2615e6be3904$
-//
-
-extern (C):
-
-///
-// Structure used to represent an entry in navigation history.
-///
-struct _cef_navigation_entry_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is valid. Do not call any other functions
-    // if this function returns false (0).
-    ///
-    int function (_cef_navigation_entry_t* self) nothrow is_valid;
-
-    ///
-    // Returns the actual URL of the page. For some pages this may be data: URL or
-    // similar. Use get_display_url() to return a display-friendly version.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_navigation_entry_t* self) nothrow get_url;
-
-    ///
-    // Returns a display-friendly version of the URL.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_navigation_entry_t* self) nothrow get_display_url;
-
-    ///
-    // Returns the original URL that was entered by the user before any redirects.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_navigation_entry_t* self) nothrow get_original_url;
-
-    ///
-    // Returns the title set by the page. This value may be NULL.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_navigation_entry_t* self) nothrow get_title;
-
-    ///
-    // Returns the transition type which indicates what the user did to move to
-    // this page from the previous page.
-    ///
-    cef_transition_type_t function (
-        _cef_navigation_entry_t* self) nothrow get_transition_type;
-
-    ///
-    // Returns true (1) if this navigation includes post data.
-    ///
-    int function (_cef_navigation_entry_t* self) nothrow has_post_data;
-
-    ///
-    // Returns the time for the last known successful navigation completion. A
-    // navigation may be completed more than once if the page is reloaded. May be
-    // 0 if the navigation has not yet completed.
-    ///
-    cef_time_t function (_cef_navigation_entry_t* self) nothrow get_completion_time;
-
-    ///
-    // Returns the HTTP status code for the last known successful navigation
-    // response. May be 0 if the response has not yet been received or if the
-    // navigation has not yet completed.
-    ///
-    int function (_cef_navigation_entry_t* self) nothrow get_http_status_code;
-
-    ///
-    // Returns the SSL information for this navigation entry.
-    ///
-    _cef_sslstatus_t* function (_cef_navigation_entry_t* self) nothrow get_sslstatus;
-}
-
-alias cef_navigation_entry_t = _cef_navigation_entry_t;
-
-// CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=8a26e2f8273298dcf44d6fbf32fd565f6aaa912c$
-//
-
-extern (C):
-
-///
-// Add an entry to the cross-origin access whitelist.
-//
-// The same-origin policy restricts how scripts hosted from different origins
-// (scheme + domain + port) can communicate. By default, scripts can only access
-// resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes
-// (but no other schemes) can use the "Access-Control-Allow-Origin" header to
-// allow cross-origin requests. For example, https://source.example.com can make
-// XMLHttpRequest requests on http://target.example.com if the
-// http://target.example.com request returns an "Access-Control-Allow-Origin:
-// https://source.example.com" response header.
-//
-// Scripts in separate frames or iframes and hosted from the same protocol and
-// domain suffix can execute cross-origin JavaScript if both pages set the
-// document.domain value to the same domain suffix. For example,
-// scheme://foo.example.com and scheme://bar.example.com can communicate using
-// JavaScript if both domains set document.domain="example.com".
-//
-// This function is used to allow access to origins that would otherwise violate
-// the same-origin policy. Scripts hosted underneath the fully qualified
-// |source_origin| URL (like http://www.example.com) will be allowed access to
-// all resources hosted on the specified |target_protocol| and |target_domain|.
-// If |target_domain| is non-NULL and |allow_target_subdomains| if false (0)
-// only exact domain matches will be allowed. If |target_domain| contains a top-
-// level domain component (like "example.com") and |allow_target_subdomains| is
-// true (1) sub-domain matches will be allowed. If |target_domain| is NULL and
-// |allow_target_subdomains| if true (1) all domains and IP addresses will be
-// allowed.
-//
-// This function cannot be used to bypass the restrictions on local or display
-// isolated schemes. See the comments on CefRegisterCustomScheme for more
-// information.
-//
-// This function may be called on any thread. Returns false (0) if
-// |source_origin| is invalid or the whitelist cannot be accessed.
-///
-int cef_add_cross_origin_whitelist_entry (
-    const(cef_string_t)* source_origin,
-    const(cef_string_t)* target_protocol,
-    const(cef_string_t)* target_domain,
-    int allow_target_subdomains);
-
-///
-// Remove an entry from the cross-origin access whitelist. Returns false (0) if
-// |source_origin| is invalid or the whitelist cannot be accessed.
-///
-int cef_remove_cross_origin_whitelist_entry (
-    const(cef_string_t)* source_origin,
-    const(cef_string_t)* target_protocol,
-    const(cef_string_t)* target_domain,
-    int allow_target_subdomains);
-
-///
-// Remove all entries from the cross-origin access whitelist. Returns false (0)
-// if the whitelist cannot be accessed.
-///
-int cef_clear_cross_origin_whitelist ();
-
-// CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=19337a70a13352e70452be7fcc25ef2de4b1ae4c$
-//
-
-extern (C):
-
-///
-// Parse the specified |url| into its component parts. Returns false (0) if the
-// URL is NULL or invalid.
-///
-int cef_parse_url (const(cef_string_t)* url, _cef_urlparts_t* parts);
-
-///
-// Creates a URL from the specified |parts|, which must contain a non-NULL spec
-// or a non-NULL host and path (at a minimum), but not both. Returns false (0)
-// if |parts| isn't initialized as described.
-///
-int cef_create_url (const(_cef_urlparts_t)* parts, cef_string_t* url);
-
-///
-// This is a convenience function for formatting a URL in a concise and human-
-// friendly way to help users make security-related decisions (or in other
-// circumstances when people need to distinguish sites, origins, or otherwise-
-// simplified URLs from each other). Internationalized domain names (IDN) may be
-// presented in Unicode if the conversion is considered safe. The returned value
-// will (a) omit the path for standard schemes, excepting file and filesystem,
-// and (b) omit the port if it is the default for the scheme. Do not use this
-// for URLs which will be parsed or sent to other applications.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-cef_string_userfree_t cef_format_url_for_security_display (
-    const(cef_string_t)* origin_url);
-
-///
-// Returns the mime type for the specified file extension or an NULL string if
-// unknown.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-cef_string_userfree_t cef_get_mime_type (const(cef_string_t)* extension);
-
-///
-// Get the extensions associated with the given mime type. This should be passed
-// in lower case. There could be multiple extensions for a given mime type, like
-// "html,htm" for "text/html", or "txt,text,html,..." for "text/*". Any existing
-// elements in the provided vector will not be erased.
-///
-void cef_get_extensions_for_mime_type (
-    const(cef_string_t)* mime_type,
-    cef_string_list_t extensions);
-
-///
-// Encodes |data| as a base64 string.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-cef_string_userfree_t cef_base64encode (const(void)* data, size_t data_size);
-
-///
-// Decodes the base64 encoded string |data|. The returned value will be NULL if
-// the decoding fails.
-///
-_cef_binary_value_t* cef_base64decode (const(cef_string_t)* data);
-
-///
-// Escapes characters in |text| which are unsuitable for use as a query
-// parameter value. Everything except alphanumerics and -_.!~*'() will be
-// converted to "%XX". If |use_plus| is true (1) spaces will change to "+". The
-// result is basically the same as encodeURIComponent in Javacript.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-cef_string_userfree_t cef_uriencode (const(cef_string_t)* text, int use_plus);
-
-///
-// Unescapes |text| and returns the result. Unescaping consists of looking for
-// the exact pattern "%XX" where each X is a hex digit and converting to the
-// character with the numerical value of those digits (e.g. "i%20=%203%3b"
-// unescapes to "i = 3;"). If |convert_to_utf8| is true (1) this function will
-// attempt to interpret the initial decoded result as UTF-8. If the result is
-// convertable into UTF-8 it will be returned as converted. Otherwise the
-// initial decoded result will be returned.  The |unescape_rule| parameter
-// supports further customization the decoding process.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-cef_string_userfree_t cef_uridecode (
-    const(cef_string_t)* text,
-    int convert_to_utf8,
-    cef_uri_unescape_rule_t unescape_rule);
-
-///
-// Parses the specified |json_string| and returns a dictionary or list
-// representation. If JSON parsing fails this function returns NULL.
-///
-_cef_value_t* cef_parse_json (
-    const(cef_string_t)* json_string,
-    cef_json_parser_options_t options);
-
-///
-// Parses the specified UTF8-encoded |json| buffer of size |json_size| and
-// returns a dictionary or list representation. If JSON parsing fails this
-// function returns NULL.
-///
-_cef_value_t* cef_parse_json_buffer (
-    const(void)* json,
-    size_t json_size,
-    cef_json_parser_options_t options);
-
-///
-// Parses the specified |json_string| and returns a dictionary or list
-// representation. If JSON parsing fails this function returns NULL and
-// populates |error_msg_out| with a formatted error message.
-///
-_cef_value_t* cef_parse_jsonand_return_error (
-    const(cef_string_t)* json_string,
-    cef_json_parser_options_t options,
-    cef_string_t* error_msg_out);
-
-///
-// Generates a JSON string from the specified root |node| which should be a
-// dictionary or list value. Returns an NULL string on failure. This function
-// requires exclusive access to |node| including any underlying data.
-///
-// The resulting string must be freed by calling cef_string_userfree_free().
-cef_string_userfree_t cef_write_json (
-    _cef_value_t* node,
-    cef_json_writer_options_t options);
-
-// CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=1b218a91d7f3ba0e68f0c3be21a0df91e515d28a$
-//
-
-extern (C):
-
-///
-// Retrieve the path associated with the specified |key|. Returns true (1) on
-// success. Can be called on any thread in the browser process.
-///
-int cef_get_path (cef_path_key_t key, cef_string_t* path);
-
-// CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=b8d7be1399d3426a3f872b12bc1438e041a16308$
-//
-
-extern (C):
-
-///
-// Callback structure for asynchronous continuation of print dialog requests.
-///
-struct _cef_print_dialog_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Continue printing with the specified |settings|.
-    ///
-    void function (
-        _cef_print_dialog_callback_t* self,
-        _cef_print_settings_t* settings) nothrow cont;
-
-    ///
-    // Cancel the printing.
-    ///
-    void function (_cef_print_dialog_callback_t* self) nothrow cancel;
-}
-
-alias cef_print_dialog_callback_t = _cef_print_dialog_callback_t;
-
-///
-// Callback structure for asynchronous continuation of print job requests.
-///
-struct _cef_print_job_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Indicate completion of the print job.
-    ///
-    void function (_cef_print_job_callback_t* self) nothrow cont;
-}
-
-alias cef_print_job_callback_t = _cef_print_job_callback_t;
-
-///
-// Implement this structure to handle printing on Linux. Each browser will have
-// only one print job in progress at a time. The functions of this structure
-// will be called on the browser process UI thread.
-///
-struct _cef_print_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called when printing has started for the specified |browser|. This function
-    // will be called before the other OnPrint*() functions and irrespective of
-    // how printing was initiated (e.g. cef_browser_host_t::print(), JavaScript
-    // window.print() or PDF extension print button).
-    ///
-    void function (
-        _cef_print_handler_t* self,
-        _cef_browser_t* browser) nothrow on_print_start;
-
-    ///
-    // Synchronize |settings| with client state. If |get_defaults| is true (1)
-    // then populate |settings| with the default print settings. Do not keep a
-    // reference to |settings| outside of this callback.
-    ///
-    void function (
-        _cef_print_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_print_settings_t* settings,
-        int get_defaults) nothrow on_print_settings;
-
-    ///
-    // Show the print dialog. Execute |callback| once the dialog is dismissed.
-    // Return true (1) if the dialog will be displayed or false (0) to cancel the
-    // printing immediately.
-    ///
-    int function (
-        _cef_print_handler_t* self,
-        _cef_browser_t* browser,
-        int has_selection,
-        _cef_print_dialog_callback_t* callback) nothrow on_print_dialog;
-
-    ///
-    // Send the print job to the printer. Execute |callback| once the job is
-    // completed. Return true (1) if the job will proceed or false (0) to cancel
-    // the job immediately.
-    ///
-    int function (
-        _cef_print_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* document_name,
-        const(cef_string_t)* pdf_file_path,
-        _cef_print_job_callback_t* callback) nothrow on_print_job;
-
-    ///
-    // Reset client state related to printing.
-    ///
-    void function (
-        _cef_print_handler_t* self,
-        _cef_browser_t* browser) nothrow on_print_reset;
-
-    ///
-    // Return the PDF paper size in device units. Used in combination with
-    // cef_browser_host_t::print_to_pdf().
-    ///
-    cef_size_t function (
-        _cef_print_handler_t* self,
-        int device_units_per_inch) nothrow get_pdf_paper_size;
-}
-
-alias cef_print_handler_t = _cef_print_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=8f7d7993691e07f4a8a42d63522c751cfba3c168$
-//
-
-extern (C):
-
-///
-// Structure representing print settings.
-///
-struct _cef_print_settings_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is valid. Do not call any other functions
-    // if this function returns false (0).
-    ///
-    int function (_cef_print_settings_t* self) nothrow is_valid;
-
-    ///
-    // Returns true (1) if the values of this object are read-only. Some APIs may
-    // expose read-only objects.
-    ///
-    int function (_cef_print_settings_t* self) nothrow is_read_only;
-
-    ///
-    // Set the page orientation.
-    ///
-    void function (_cef_print_settings_t* self, int landscape) nothrow set_orientation;
-
-    ///
-    // Returns true (1) if the orientation is landscape.
-    ///
-    int function (_cef_print_settings_t* self) nothrow is_landscape;
-
-    ///
-    // Set the printer printable area in device units. Some platforms already
-    // provide flipped area. Set |landscape_needs_flip| to false (0) on those
-    // platforms to avoid double flipping.
-    ///
-    void function (
-        _cef_print_settings_t* self,
-        const(cef_size_t)* physical_size_device_units,
-        const(cef_rect_t)* printable_area_device_units,
-        int landscape_needs_flip) nothrow set_printer_printable_area;
-
-    ///
-    // Set the device name.
-    ///
-    void function (
-        _cef_print_settings_t* self,
-        const(cef_string_t)* name) nothrow set_device_name;
-
-    ///
-    // Get the device name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_print_settings_t* self) nothrow get_device_name;
-
-    ///
-    // Set the DPI (dots per inch).
-    ///
-    void function (_cef_print_settings_t* self, int dpi) nothrow set_dpi;
-
-    ///
-    // Get the DPI (dots per inch).
-    ///
-    int function (_cef_print_settings_t* self) nothrow get_dpi;
-
-    ///
-    // Set the page ranges.
-    ///
-    void function (
-        _cef_print_settings_t* self,
-        size_t rangesCount,
-        const(cef_range_t)* ranges) nothrow set_page_ranges;
-
-    ///
-    // Returns the number of page ranges that currently exist.
-    ///
-    size_t function (_cef_print_settings_t* self) nothrow get_page_ranges_count;
-
-    ///
-    // Retrieve the page ranges.
-    ///
-    void function (
-        _cef_print_settings_t* self,
-        size_t* rangesCount,
-        cef_range_t* ranges) nothrow get_page_ranges;
-
-    ///
-    // Set whether only the selection will be printed.
-    ///
-    void function (
-        _cef_print_settings_t* self,
-        int selection_only) nothrow set_selection_only;
-
-    ///
-    // Returns true (1) if only the selection will be printed.
-    ///
-    int function (_cef_print_settings_t* self) nothrow is_selection_only;
-
-    ///
-    // Set whether pages will be collated.
-    ///
-    void function (_cef_print_settings_t* self, int collate) nothrow set_collate;
-
-    ///
-    // Returns true (1) if pages will be collated.
-    ///
-    int function (_cef_print_settings_t* self) nothrow will_collate;
-
-    ///
-    // Set the color model.
-    ///
-    void function (
-        _cef_print_settings_t* self,
-        cef_color_model_t model) nothrow set_color_model;
-
-    ///
-    // Get the color model.
-    ///
-    cef_color_model_t function (_cef_print_settings_t* self) nothrow get_color_model;
-
-    ///
-    // Set the number of copies.
-    ///
-    void function (_cef_print_settings_t* self, int copies) nothrow set_copies;
-
-    ///
-    // Get the number of copies.
-    ///
-    int function (_cef_print_settings_t* self) nothrow get_copies;
-
-    ///
-    // Set the duplex mode.
-    ///
-    void function (
-        _cef_print_settings_t* self,
-        cef_duplex_mode_t mode) nothrow set_duplex_mode;
-
-    ///
-    // Get the duplex mode.
-    ///
-    cef_duplex_mode_t function (_cef_print_settings_t* self) nothrow get_duplex_mode;
-}
-
-alias cef_print_settings_t = _cef_print_settings_t;
-
-///
-// Create a new cef_print_settings_t object.
-///
-cef_print_settings_t* cef_print_settings_create ();
-
-// CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=79ec6d99ea47e1cf9b2cca0433704f205e14d3bd$
-//
-
-extern (C):
-
-///
-// Structure representing a message. Can be used on any process and thread.
-///
-struct _cef_process_message_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is valid. Do not call any other functions
-    // if this function returns false (0).
-    ///
-    int function (_cef_process_message_t* self) nothrow is_valid;
-
-    ///
-    // Returns true (1) if the values of this object are read-only. Some APIs may
-    // expose read-only objects.
-    ///
-    int function (_cef_process_message_t* self) nothrow is_read_only;
-
-    ///
-    // Returns a writable copy of this object.
-    ///
-    _cef_process_message_t* function (_cef_process_message_t* self) nothrow copy;
-
-    ///
-    // Returns the message name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_process_message_t* self) nothrow get_name;
-
-    ///
-    // Returns the list of arguments.
-    ///
-    _cef_list_value_t* function (
-        _cef_process_message_t* self) nothrow get_argument_list;
-}
-
-alias cef_process_message_t = _cef_process_message_t;
-
-///
-// Create a new cef_process_message_t object with the specified name.
-///
-cef_process_message_t* cef_process_message_create (const(cef_string_t)* name);
-
-// CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=75b16fd9d592c1d22b94d740e1deb61efe3afb97$
-//
-
-extern (C):
-
-///
-// Launches the process specified via |command_line|. Returns true (1) upon
-// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.
-//
-// Unix-specific notes: - All file descriptors open in the parent process will
-// be closed in the
-//   child process except for stdin, stdout, and stderr.
-// - If the first argument on the command line does not contain a slash,
-//   PATH will be searched. (See man execvp.)
-///
-int cef_launch_process (_cef_command_line_t* command_line);
-
-// CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=029e237cf80f94a25453bac5a9b1e0765bb56f37$
-//
-
-extern (C):
-
-///
-// Generic callback structure used for managing the lifespan of a registration.
-///
-struct _cef_registration_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-}
-
-alias cef_registration_t = _cef_registration_t;
-
-// CEF_INCLUDE_CAPI_CEF_REGISTRATION_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=f9806cd79f33b6a762fff25edd4189ae42bc8fd2$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle events when window rendering is disabled.
-// The functions of this structure will be called on the UI thread.
-///
-struct _cef_render_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Return the handler for accessibility notifications. If no handler is
-    // provided the default implementation will be used.
-    ///
-    _cef_accessibility_handler_t* function (
-        _cef_render_handler_t* self) nothrow get_accessibility_handler;
-
-    ///
-    // Called to retrieve the root window rectangle in screen coordinates. Return
-    // true (1) if the rectangle was provided. If this function returns false (0)
-    // the rectangle from GetViewRect will be used.
-    ///
-    int function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        cef_rect_t* rect) nothrow get_root_screen_rect;
-
-    ///
-    // Called to retrieve the view rectangle which is relative to screen
-    // coordinates. This function must always provide a non-NULL rectangle.
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        cef_rect_t* rect) nothrow get_view_rect;
-
-    ///
-    // Called to retrieve the translation from view coordinates to actual screen
-    // coordinates. Return true (1) if the screen coordinates were provided.
-    ///
-    int function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        int viewX,
-        int viewY,
-        int* screenX,
-        int* screenY) nothrow get_screen_point;
-
-    ///
-    // Called to allow the client to fill in the CefScreenInfo object with
-    // appropriate values. Return true (1) if the |screen_info| structure has been
-    // modified.
-    //
-    // If the screen info rectangle is left NULL the rectangle from GetViewRect
-    // will be used. If the rectangle is still NULL or invalid popups may not be
-    // drawn correctly.
-    ///
-    int function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_screen_info_t* screen_info) nothrow get_screen_info;
-
-    ///
-    // Called when the browser wants to show or hide the popup widget. The popup
-    // should be shown if |show| is true (1) and hidden if |show| is false (0).
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        int show) nothrow on_popup_show;
-
-    ///
-    // Called when the browser wants to move or resize the popup widget. |rect|
-    // contains the new location and size in view coordinates.
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_rect_t)* rect) nothrow on_popup_size;
-
-    ///
-    // Called when an element should be painted. Pixel values passed to this
-    // function are scaled relative to view coordinates based on the value of
-    // CefScreenInfo.device_scale_factor returned from GetScreenInfo. |type|
-    // indicates whether the element is the view or the popup widget. |buffer|
-    // contains the pixel data for the whole image. |dirtyRects| contains the set
-    // of rectangles in pixel coordinates that need to be repainted. |buffer| will
-    // be |width|*|height|*4 bytes in size and represents a BGRA image with an
-    // upper-left origin. This function is only called when
-    // cef_window_tInfo::shared_texture_enabled is set to false (0).
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        cef_paint_element_type_t type,
-        size_t dirtyRectsCount,
-        const(cef_rect_t)* dirtyRects,
-        const(void)* buffer,
-        int width,
-        int height) nothrow on_paint;
-
-    ///
-    // Called when an element has been rendered to the shared texture handle.
-    // |type| indicates whether the element is the view or the popup widget.
-    // |dirtyRects| contains the set of rectangles in pixel coordinates that need
-    // to be repainted. |shared_handle| is the handle for a D3D11 Texture2D that
-    // can be accessed via ID3D11Device using the OpenSharedResource function.
-    // This function is only called when cef_window_tInfo::shared_texture_enabled
-    // is set to true (1), and is currently only supported on Windows.
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        cef_paint_element_type_t type,
-        size_t dirtyRectsCount,
-        const(cef_rect_t)* dirtyRects,
-        void* shared_handle) nothrow on_accelerated_paint;
-
-    ///
-    // Called when the user starts dragging content in the web view. Contextual
-    // information about the dragged content is supplied by |drag_data|. (|x|,
-    // |y|) is the drag start location in screen coordinates. OS APIs that run a
-    // system message loop may be used within the StartDragging call.
-    //
-    // Return false (0) to abort the drag operation. Don't call any of
-    // cef_browser_host_t::DragSource*Ended* functions after returning false (0).
-    //
-    // Return true (1) to handle the drag operation. Call
-    // cef_browser_host_t::DragSourceEndedAt and DragSourceSystemDragEnded either
-    // synchronously or asynchronously to inform the web view that the drag
-    // operation has ended.
-    ///
-    int function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_drag_data_t* drag_data,
-        cef_drag_operations_mask_t allowed_ops,
-        int x,
-        int y) nothrow start_dragging;
-
-    ///
-    // Called when the web view wants to update the mouse cursor during a drag &
-    // drop operation. |operation| describes the allowed operation (none, move,
-    // copy, link).
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        cef_drag_operations_mask_t operation) nothrow update_drag_cursor;
-
-    ///
-    // Called when the scroll offset has changed.
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        double x,
-        double y) nothrow on_scroll_offset_changed;
-
-    ///
-    // Called when the IME composition range has changed. |selected_range| is the
-    // range of characters that have been selected. |character_bounds| is the
-    // bounds of each character in view coordinates.
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_range_t)* selected_range,
-        size_t character_boundsCount,
-        const(cef_rect_t)* character_bounds) nothrow on_ime_composition_range_changed;
-
-    ///
-    // Called when text selection has changed for the specified |browser|.
-    // |selected_text| is the currently selected text and |selected_range| is the
-    // character range.
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* selected_text,
-        const(cef_range_t)* selected_range) nothrow on_text_selection_changed;
-
-    ///
-    // Called when an on-screen keyboard should be shown or hidden for the
-    // specified |browser|. |input_mode| specifies what kind of keyboard should be
-    // opened. If |input_mode| is CEF_TEXT_INPUT_MODE_NONE, any existing keyboard
-    // for this browser should be hidden.
-    ///
-    void function (
-        _cef_render_handler_t* self,
-        _cef_browser_t* browser,
-        cef_text_input_mode_t input_mode) nothrow on_virtual_keyboard_requested;
-}
-
-alias cef_render_handler_t = _cef_render_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=8419eb3eba9dd372b019bd367d4f195433b21c9b$
-//
-
-extern (C):
-
-///
-// Structure used to implement render process callbacks. The functions of this
-// structure will be called on the render process main thread (TID_RENDERER)
-// unless otherwise indicated.
-///
-struct _cef_render_process_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called after WebKit has been initialized.
-    ///
-    void function (_cef_render_process_handler_t* self) nothrow on_web_kit_initialized;
-
-    ///
-    // Called after a browser has been created. When browsing cross-origin a new
-    // browser will be created before the old browser with the same identifier is
-    // destroyed. |extra_info| is a read-only value originating from
-    // cef_browser_host_t::cef_browser_host_create_browser(),
-    // cef_browser_host_t::cef_browser_host_create_browser_sync(),
-    // cef_life_span_handler_t::on_before_popup() or
-    // cef_browser_view_t::cef_browser_view_create().
-    ///
-    void function (
-        _cef_render_process_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_dictionary_value_t* extra_info) nothrow on_browser_created;
-
-    ///
-    // Called before a browser is destroyed.
-    ///
-    void function (
-        _cef_render_process_handler_t* self,
-        _cef_browser_t* browser) nothrow on_browser_destroyed;
-
-    ///
-    // Return the handler for browser load status events.
-    ///
-    _cef_load_handler_t* function (
-        _cef_render_process_handler_t* self) nothrow get_load_handler;
-
-    ///
-    // Called immediately after the V8 context for a frame has been created. To
-    // retrieve the JavaScript 'window' object use the
-    // cef_v8context_t::get_global() function. V8 handles can only be accessed
-    // from the thread on which they are created. A task runner for posting tasks
-    // on the associated thread can be retrieved via the
-    // cef_v8context_t::get_task_runner() function.
-    ///
-    void function (
-        _cef_render_process_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_v8context_t* context) nothrow on_context_created;
-
-    ///
-    // Called immediately before the V8 context for a frame is released. No
-    // references to the context should be kept after this function is called.
-    ///
-    void function (
-        _cef_render_process_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_v8context_t* context) nothrow on_context_released;
-
-    ///
-    // Called for global uncaught exceptions in a frame. Execution of this
-    // callback is disabled by default. To enable set
-    // CefSettings.uncaught_exception_stack_size > 0.
-    ///
-    void function (
-        _cef_render_process_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_v8context_t* context,
-        _cef_v8exception_t* exception,
-        _cef_v8stack_trace_t* stackTrace) nothrow on_uncaught_exception;
-
-    ///
-    // Called when a new node in the the browser gets focus. The |node| value may
-    // be NULL if no specific node has gained focus. The node object passed to
-    // this function represents a snapshot of the DOM at the time this function is
-    // executed. DOM objects are only valid for the scope of this function. Do not
-    // keep references to or attempt to access any DOM objects outside the scope
-    // of this function.
-    ///
-    void function (
-        _cef_render_process_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_domnode_t* node) nothrow on_focused_node_changed;
-
-    ///
-    // Called when a new message is received from a different process. Return true
-    // (1) if the message was handled or false (0) otherwise. Do not keep a
-    // reference to or attempt to access the message outside of this callback.
-    ///
-    int function (
-        _cef_render_process_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        cef_process_id_t source_process,
-        _cef_process_message_t* message) nothrow on_process_message_received;
-}
-
-alias cef_render_process_handler_t = _cef_render_process_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=3efd81a4bfdfca579a77f14bd37b8192122ebda4$
-//
-
-extern (C):
-
-///
-// Callback structure used for asynchronous continuation of url requests.
-///
-struct _cef_request_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Continue the url request. If |allow| is true (1) the request will be
-    // continued. Otherwise, the request will be canceled.
-    ///
-    void function (_cef_request_callback_t* self, int allow) nothrow cont;
-
-    ///
-    // Cancel the url request.
-    ///
-    void function (_cef_request_callback_t* self) nothrow cancel;
-}
-
-alias cef_request_callback_t = _cef_request_callback_t;
-
-// CEF_INCLUDE_CAPI_CEF_REQUEST_CALLBACK_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=b3725b8fa4118936caacda69504dc597f3620d82$
-//
-
-extern (C):
-
-///
-// Structure used to represent a web request. The functions of this structure
-// may be called on any thread.
-///
-struct _cef_request_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is read-only.
-    ///
-    int function (_cef_request_t* self) nothrow is_read_only;
-
-    ///
-    // Get the fully qualified URL.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_request_t* self) nothrow get_url;
-
-    ///
-    // Set the fully qualified URL.
-    ///
-    void function (_cef_request_t* self, const(cef_string_t)* url) nothrow set_url;
-
-    ///
-    // Get the request function type. The value will default to POST if post data
-    // is provided and GET otherwise.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_request_t* self) nothrow get_method;
-
-    ///
-    // Set the request function type.
-    ///
-    void function (
-        _cef_request_t* self,
-        const(cef_string_t)* method) nothrow set_method;
-
-    ///
-    // Set the referrer URL and policy. If non-NULL the referrer URL must be fully
-    // qualified with an HTTP or HTTPS scheme component. Any username, password or
-    // ref component will be removed.
-    ///
-    void function (
-        _cef_request_t* self,
-        const(cef_string_t)* referrer_url,
-        cef_referrer_policy_t policy) nothrow set_referrer;
-
-    ///
-    // Get the referrer URL.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_request_t* self) nothrow get_referrer_url;
-
-    ///
-    // Get the referrer policy.
-    ///
-    cef_referrer_policy_t function (_cef_request_t* self) nothrow get_referrer_policy;
-
-    ///
-    // Get the post data.
-    ///
-    _cef_post_data_t* function (_cef_request_t* self) nothrow get_post_data;
-
-    ///
-    // Set the post data.
-    ///
-    void function (
-        _cef_request_t* self,
-        _cef_post_data_t* postData) nothrow set_post_data;
-
-    ///
-    // Get the header values. Will not include the Referer value if any.
-    ///
-    void function (
-        _cef_request_t* self,
-        cef_string_multimap_t headerMap) nothrow get_header_map;
-
-    ///
-    // Set the header values. If a Referer value exists in the header map it will
-    // be removed and ignored.
-    ///
-    void function (
-        _cef_request_t* self,
-        cef_string_multimap_t headerMap) nothrow set_header_map;
-
-    ///
-    // Returns the first header value for |name| or an NULL string if not found.
-    // Will not return the Referer value if any. Use GetHeaderMap instead if
-    // |name| might have multiple values.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_request_t* self,
-        const(cef_string_t)* name) nothrow get_header_by_name;
-
-    ///
-    // Set the header |name| to |value|. If |overwrite| is true (1) any existing
-    // values will be replaced with the new value. If |overwrite| is false (0) any
-    // existing values will not be overwritten. The Referer value cannot be set
-    // using this function.
-    ///
-    void function (
-        _cef_request_t* self,
-        const(cef_string_t)* name,
-        const(cef_string_t)* value,
-        int overwrite) nothrow set_header_by_name;
-
-    ///
-    // Set all values at one time.
-    ///
-    void function (
-        _cef_request_t* self,
-        const(cef_string_t)* url,
-        const(cef_string_t)* method,
-        _cef_post_data_t* postData,
-        cef_string_multimap_t headerMap) nothrow set;
-
-    ///
-    // Get the flags used in combination with cef_urlrequest_t. See
-    // cef_urlrequest_flags_t for supported values.
-    ///
-    int function (_cef_request_t* self) nothrow get_flags;
-
-    ///
-    // Set the flags used in combination with cef_urlrequest_t.  See
-    // cef_urlrequest_flags_t for supported values.
-    ///
-    void function (_cef_request_t* self, int flags) nothrow set_flags;
-
-    ///
-    // Get the URL to the first party for cookies used in combination with
-    // cef_urlrequest_t.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_request_t* self) nothrow get_first_party_for_cookies;
-
-    ///
-    // Set the URL to the first party for cookies used in combination with
-    // cef_urlrequest_t.
-    ///
-    void function (
-        _cef_request_t* self,
-        const(cef_string_t)* url) nothrow set_first_party_for_cookies;
-
-    ///
-    // Get the resource type for this request. Only available in the browser
-    // process.
-    ///
-    cef_resource_type_t function (_cef_request_t* self) nothrow get_resource_type;
-
-    ///
-    // Get the transition type for this request. Only available in the browser
-    // process and only applies to requests that represent a main frame or sub-
-    // frame navigation.
-    ///
-    cef_transition_type_t function (_cef_request_t* self) nothrow get_transition_type;
-
-    ///
-    // Returns the globally unique identifier for this request or 0 if not
-    // specified. Can be used by cef_resource_request_handler_t implementations in
-    // the browser process to track a single request across multiple callbacks.
-    ///
-    uint64 function (_cef_request_t* self) nothrow get_identifier;
-}
-
-alias cef_request_t = _cef_request_t;
-
-///
-// Create a new cef_request_t object.
-///
-cef_request_t* cef_request_create ();
-
-///
-// Structure used to represent post data for a web request. The functions of
-// this structure may be called on any thread.
-///
-struct _cef_post_data_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is read-only.
-    ///
-    int function (_cef_post_data_t* self) nothrow is_read_only;
-
-    ///
-    // Returns true (1) if the underlying POST data includes elements that are not
-    // represented by this cef_post_data_t object (for example, multi-part file
-    // upload data). Modifying cef_post_data_t objects with excluded elements may
-    // result in the request failing.
-    ///
-    int function (_cef_post_data_t* self) nothrow has_excluded_elements;
-
-    ///
-    // Returns the number of existing post data elements.
-    ///
-    size_t function (_cef_post_data_t* self) nothrow get_element_count;
-
-    ///
-    // Retrieve the post data elements.
-    ///
-    void function (
-        _cef_post_data_t* self,
-        size_t* elementsCount,
-        _cef_post_data_element_t** elements) nothrow get_elements;
-
-    ///
-    // Remove the specified post data element.  Returns true (1) if the removal
-    // succeeds.
-    ///
-    int function (
-        _cef_post_data_t* self,
-        _cef_post_data_element_t* element) nothrow remove_element;
-
-    ///
-    // Add the specified post data element.  Returns true (1) if the add succeeds.
-    ///
-    int function (
-        _cef_post_data_t* self,
-        _cef_post_data_element_t* element) nothrow add_element;
-
-    ///
-    // Remove all existing post data elements.
-    ///
-    void function (_cef_post_data_t* self) nothrow remove_elements;
-}
-
-alias cef_post_data_t = _cef_post_data_t;
-
-///
-// Create a new cef_post_data_t object.
-///
-cef_post_data_t* cef_post_data_create ();
-
-///
-// Structure used to represent a single element in the request post data. The
-// functions of this structure may be called on any thread.
-///
-struct _cef_post_data_element_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is read-only.
-    ///
-    int function (_cef_post_data_element_t* self) nothrow is_read_only;
-
-    ///
-    // Remove all contents from the post data element.
-    ///
-    void function (_cef_post_data_element_t* self) nothrow set_to_empty;
-
-    ///
-    // The post data element will represent a file.
-    ///
-    void function (
-        _cef_post_data_element_t* self,
-        const(cef_string_t)* fileName) nothrow set_to_file;
-
-    ///
-    // The post data element will represent bytes.  The bytes passed in will be
-    // copied.
-    ///
-    void function (
-        _cef_post_data_element_t* self,
-        size_t size,
-        const(void)* bytes) nothrow set_to_bytes;
-
-    ///
-    // Return the type of this post data element.
-    ///
-    cef_postdataelement_type_t function (
-        _cef_post_data_element_t* self) nothrow get_type;
-
-    ///
-    // Return the file name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_post_data_element_t* self) nothrow get_file;
-
-    ///
-    // Return the number of bytes.
-    ///
-    size_t function (_cef_post_data_element_t* self) nothrow get_bytes_count;
-
-    ///
-    // Read up to |size| bytes into |bytes| and return the number of bytes
-    // actually read.
-    ///
-    size_t function (
-        _cef_post_data_element_t* self,
-        size_t size,
-        void* bytes) nothrow get_bytes;
-}
-
-alias cef_post_data_element_t = _cef_post_data_element_t;
-
-///
-// Create a new cef_post_data_element_t object.
-///
-cef_post_data_element_t* cef_post_data_element_create ();
-
-// CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=e758d8c53334b91bce818cc6e9f84915778d7827$
-//
-
-extern (C):
-
-///
-// Implement this structure to provide handler implementations. The handler
-// instance will not be released until all objects related to the context have
-// been destroyed.
-///
-struct _cef_request_context_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called on the browser process UI thread immediately after the request
-    // context has been initialized.
-    ///
-    void function (
-        _cef_request_context_handler_t* self,
-        _cef_request_context_t* request_context) nothrow on_request_context_initialized;
-
-    ///
-    // Called on multiple browser process threads before a plugin instance is
-    // loaded. |mime_type| is the mime type of the plugin that will be loaded.
-    // |plugin_url| is the content URL that the plugin will load and may be NULL.
-    // |is_main_frame| will be true (1) if the plugin is being loaded in the main
-    // (top-level) frame, |top_origin_url| is the URL for the top-level frame that
-    // contains the plugin when loading a specific plugin instance or NULL when
-    // building the initial list of enabled plugins for 'navigator.plugins'
-    // JavaScript state. |plugin_info| includes additional information about the
-    // plugin that will be loaded. |plugin_policy| is the recommended policy.
-    // Modify |plugin_policy| and return true (1) to change the policy. Return
-    // false (0) to use the recommended policy. The default plugin policy can be
-    // set at runtime using the `--plugin-policy=[allow|detect|block]` command-
-    // line flag. Decisions to mark a plugin as disabled by setting
-    // |plugin_policy| to PLUGIN_POLICY_DISABLED may be cached when
-    // |top_origin_url| is NULL. To purge the plugin list cache and potentially
-    // trigger new calls to this function call
-    // cef_request_context_t::PurgePluginListCache.
-    ///
-    int function (
-        _cef_request_context_handler_t* self,
-        const(cef_string_t)* mime_type,
-        const(cef_string_t)* plugin_url,
-        int is_main_frame,
-        const(cef_string_t)* top_origin_url,
-        _cef_web_plugin_info_t* plugin_info,
-        cef_plugin_policy_t* plugin_policy) nothrow on_before_plugin_load;
-
-    ///
-    // Called on the browser process IO thread before a resource request is
-    // initiated. The |browser| and |frame| values represent the source of the
-    // request, and may be NULL for requests originating from service workers or
-    // cef_urlrequest_t. |request| represents the request contents and cannot be
-    // modified in this callback. |is_navigation| will be true (1) if the resource
-    // request is a navigation. |is_download| will be true (1) if the resource
-    // request is a download. |request_initiator| is the origin (scheme + domain)
-    // of the page that initiated the request. Set |disable_default_handling| to
-    // true (1) to disable default handling of the request, in which case it will
-    // need to be handled via cef_resource_request_handler_t::GetResourceHandler
-    // or it will be canceled. To allow the resource load to proceed with default
-    // handling return NULL. To specify a handler for the resource return a
-    // cef_resource_request_handler_t object. This function will not be called if
-    // the client associated with |browser| returns a non-NULL value from
-    // cef_request_handler_t::GetResourceRequestHandler for the same request
-    // (identified by cef_request_t::GetIdentifier).
-    ///
-    _cef_resource_request_handler_t* function (
-        _cef_request_context_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        int is_navigation,
-        int is_download,
-        const(cef_string_t)* request_initiator,
-        int* disable_default_handling) nothrow get_resource_request_handler;
-}
-
-alias cef_request_context_handler_t = _cef_request_context_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=0167eb1abe614bd6391d273a8085fa3e53e7c217$
-//
-
-extern (C):
-
-///
-// Callback structure used to select a client certificate for authentication.
-///
-struct _cef_select_client_certificate_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Chooses the specified certificate for client certificate authentication.
-    // NULL value means that no client certificate should be used.
-    ///
-    void function (
-        _cef_select_client_certificate_callback_t* self,
-        _cef_x509certificate_t* cert) nothrow select;
-}
-
-alias cef_select_client_certificate_callback_t = _cef_select_client_certificate_callback_t;
-
-///
-// Implement this structure to handle events related to browser requests. The
-// functions of this structure will be called on the thread indicated.
-///
-struct _cef_request_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called on the UI thread before browser navigation. Return true (1) to
-    // cancel the navigation or false (0) to allow the navigation to proceed. The
-    // |request| object cannot be modified in this callback.
-    // cef_load_handler_t::OnLoadingStateChange will be called twice in all cases.
-    // If the navigation is allowed cef_load_handler_t::OnLoadStart and
-    // cef_load_handler_t::OnLoadEnd will be called. If the navigation is canceled
-    // cef_load_handler_t::OnLoadError will be called with an |errorCode| value of
-    // ERR_ABORTED. The |user_gesture| value will be true (1) if the browser
-    // navigated via explicit user gesture (e.g. clicking a link) or false (0) if
-    // it navigated automatically (e.g. via the DomContentLoaded event).
-    ///
-    int function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        int user_gesture,
-        int is_redirect) nothrow on_before_browse;
-
-    ///
-    // Called on the UI thread before OnBeforeBrowse in certain limited cases
-    // where navigating a new or different browser might be desirable. This
-    // includes user-initiated navigation that might open in a special way (e.g.
-    // links clicked via middle-click or ctrl + left-click) and certain types of
-    // cross-origin navigation initiated from the renderer process (e.g.
-    // navigating the top-level frame to/from a file URL). The |browser| and
-    // |frame| values represent the source of the navigation. The
-    // |target_disposition| value indicates where the user intended to navigate
-    // the browser based on standard Chromium behaviors (e.g. current tab, new
-    // tab, etc). The |user_gesture| value will be true (1) if the browser
-    // navigated via explicit user gesture (e.g. clicking a link) or false (0) if
-    // it navigated automatically (e.g. via the DomContentLoaded event). Return
-    // true (1) to cancel the navigation or false (0) to allow the navigation to
-    // proceed in the source browser's top-level frame.
-    ///
-    int function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        const(cef_string_t)* target_url,
-        cef_window_open_disposition_t target_disposition,
-        int user_gesture) nothrow on_open_urlfrom_tab;
-
-    ///
-    // Called on the browser process IO thread before a resource request is
-    // initiated. The |browser| and |frame| values represent the source of the
-    // request. |request| represents the request contents and cannot be modified
-    // in this callback. |is_navigation| will be true (1) if the resource request
-    // is a navigation. |is_download| will be true (1) if the resource request is
-    // a download. |request_initiator| is the origin (scheme + domain) of the page
-    // that initiated the request. Set |disable_default_handling| to true (1) to
-    // disable default handling of the request, in which case it will need to be
-    // handled via cef_resource_request_handler_t::GetResourceHandler or it will
-    // be canceled. To allow the resource load to proceed with default handling
-    // return NULL. To specify a handler for the resource return a
-    // cef_resource_request_handler_t object. If this callback returns NULL the
-    // same function will be called on the associated
-    // cef_request_context_handler_t, if any.
-    ///
-    _cef_resource_request_handler_t* function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        int is_navigation,
-        int is_download,
-        const(cef_string_t)* request_initiator,
-        int* disable_default_handling) nothrow get_resource_request_handler;
-
-    ///
-    // Called on the IO thread when the browser needs credentials from the user.
-    // |origin_url| is the origin making this authentication request. |isProxy|
-    // indicates whether the host is a proxy server. |host| contains the hostname
-    // and |port| contains the port number. |realm| is the realm of the challenge
-    // and may be NULL. |scheme| is the authentication scheme used, such as
-    // "basic" or "digest", and will be NULL if the source of the request is an
-    // FTP server. Return true (1) to continue the request and call
-    // cef_auth_callback_t::cont() either in this function or at a later time when
-    // the authentication information is available. Return false (0) to cancel the
-    // request immediately.
-    ///
-    int function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* origin_url,
-        int isProxy,
-        const(cef_string_t)* host,
-        int port,
-        const(cef_string_t)* realm,
-        const(cef_string_t)* scheme,
-        _cef_auth_callback_t* callback) nothrow get_auth_credentials;
-
-    ///
-    // Called on the IO thread when JavaScript requests a specific storage quota
-    // size via the webkitStorageInfo.requestQuota function. |origin_url| is the
-    // origin of the page making the request. |new_size| is the requested quota
-    // size in bytes. Return true (1) to continue the request and call
-    // cef_request_callback_t::cont() either in this function or at a later time
-    // to grant or deny the request. Return false (0) to cancel the request
-    // immediately.
-    ///
-    int function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* origin_url,
-        int64 new_size,
-        _cef_request_callback_t* callback) nothrow on_quota_request;
-
-    ///
-    // Called on the UI thread to handle requests for URLs with an invalid SSL
-    // certificate. Return true (1) and call cef_request_callback_t::cont() either
-    // in this function or at a later time to continue or cancel the request.
-    // Return false (0) to cancel the request immediately. If
-    // CefSettings.ignore_certificate_errors is set all invalid certificates will
-    // be accepted without calling this function.
-    ///
-    int function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser,
-        cef_errorcode_t cert_error,
-        const(cef_string_t)* request_url,
-        _cef_sslinfo_t* ssl_info,
-        _cef_request_callback_t* callback) nothrow on_certificate_error;
-
-    ///
-    // Called on the UI thread when a client certificate is being requested for
-    // authentication. Return false (0) to use the default behavior and
-    // automatically select the first certificate available. Return true (1) and
-    // call cef_select_client_certificate_callback_t::Select either in this
-    // function or at a later time to select a certificate. Do not call Select or
-    // call it with NULL to continue without using any certificate. |isProxy|
-    // indicates whether the host is an HTTPS proxy or the origin server. |host|
-    // and |port| contains the hostname and port of the SSL server. |certificates|
-    // is the list of certificates to choose from; this list has already been
-    // pruned by Chromium so that it only contains certificates from issuers that
-    // the server trusts.
-    ///
-    int function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser,
-        int isProxy,
-        const(cef_string_t)* host,
-        int port,
-        size_t certificatesCount,
-        _cef_x509certificate_t** certificates,
-        _cef_select_client_certificate_callback_t* callback) nothrow on_select_client_certificate;
-
-    ///
-    // Called on the browser process UI thread when a plugin has crashed.
-    // |plugin_path| is the path of the plugin that crashed.
-    ///
-    void function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser,
-        const(cef_string_t)* plugin_path) nothrow on_plugin_crashed;
-
-    ///
-    // Called on the browser process UI thread when the render view associated
-    // with |browser| is ready to receive/handle IPC messages in the render
-    // process.
-    ///
-    void function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser) nothrow on_render_view_ready;
-
-    ///
-    // Called on the browser process UI thread when the render process terminates
-    // unexpectedly. |status| indicates how the process terminated.
-    ///
-    void function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser,
-        cef_termination_status_t status) nothrow on_render_process_terminated;
-
-    ///
-    // Called on the browser process UI thread when the window.document object of
-    // the main frame has been created.
-    ///
-    void function (
-        _cef_request_handler_t* self,
-        _cef_browser_t* browser) nothrow on_document_available_in_main_frame;
-}
-
-alias cef_request_handler_t = _cef_request_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=b0e2b63b467c6d4e990405d948908da3546ea1c7$
-//
-
-extern (C):
-
-///
-// Structure used for retrieving resources from the resource bundle (*.pak)
-// files loaded by CEF during startup or via the cef_resource_bundle_handler_t
-// returned from cef_app_t::GetResourceBundleHandler. See CefSettings for
-// additional options related to resource bundle loading. The functions of this
-// structure may be called on any thread unless otherwise indicated.
-///
-struct _cef_resource_bundle_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the localized string for the specified |string_id| or an NULL
-    // string if the value is not found. Include cef_pack_strings.h for a listing
-    // of valid string ID values.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_resource_bundle_t* self,
-        int string_id) nothrow get_localized_string;
-
-    ///
-    // Returns a cef_binary_value_t containing the decompressed contents of the
-    // specified scale independent |resource_id| or NULL if not found. Include
-    // cef_pack_resources.h for a listing of valid resource ID values.
-    ///
-    _cef_binary_value_t* function (
-        _cef_resource_bundle_t* self,
-        int resource_id) nothrow get_data_resource;
-
-    ///
-    // Returns a cef_binary_value_t containing the decompressed contents of the
-    // specified |resource_id| nearest the scale factor |scale_factor| or NULL if
-    // not found. Use a |scale_factor| value of SCALE_FACTOR_NONE for scale
-    // independent resources or call GetDataResource instead.Include
-    // cef_pack_resources.h for a listing of valid resource ID values.
-    ///
-    _cef_binary_value_t* function (
-        _cef_resource_bundle_t* self,
-        int resource_id,
-        cef_scale_factor_t scale_factor) nothrow get_data_resource_for_scale;
-}
-
-alias cef_resource_bundle_t = _cef_resource_bundle_t;
-
-///
-// Returns the global resource bundle instance.
-///
-cef_resource_bundle_t* cef_resource_bundle_get_global ();
-
-// CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=fd90a707c59a8c04b1b1bfc6129a90e27934f501$
-//
-
-extern (C):
-
-///
-// Structure used to implement a custom resource bundle structure. See
-// CefSettings for additional options related to resource bundle loading. The
-// functions of this structure may be called on multiple threads.
-///
-struct _cef_resource_bundle_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called to retrieve a localized translation for the specified |string_id|.
-    // To provide the translation set |string| to the translation string and
-    // return true (1). To use the default translation return false (0). Include
-    // cef_pack_strings.h for a listing of valid string ID values.
-    ///
-    int function (
-        _cef_resource_bundle_handler_t* self,
-        int string_id,
-        cef_string_t* string) nothrow get_localized_string;
-
-    ///
-    // Called to retrieve data for the specified scale independent |resource_id|.
-    // To provide the resource data set |data| and |data_size| to the data pointer
-    // and size respectively and return true (1). To use the default resource data
-    // return false (0). The resource data will not be copied and must remain
-    // resident in memory. Include cef_pack_resources.h for a listing of valid
-    // resource ID values.
-    ///
-    int function (
-        _cef_resource_bundle_handler_t* self,
-        int resource_id,
-        void** data,
-        size_t* data_size) nothrow get_data_resource;
-
-    ///
-    // Called to retrieve data for the specified |resource_id| nearest the scale
-    // factor |scale_factor|. To provide the resource data set |data| and
-    // |data_size| to the data pointer and size respectively and return true (1).
-    // To use the default resource data return false (0). The resource data will
-    // not be copied and must remain resident in memory. Include
-    // cef_pack_resources.h for a listing of valid resource ID values.
-    ///
-    int function (
-        _cef_resource_bundle_handler_t* self,
-        int resource_id,
-        cef_scale_factor_t scale_factor,
-        void** data,
-        size_t* data_size) nothrow get_data_resource_for_scale;
-}
-
-alias cef_resource_bundle_handler_t = _cef_resource_bundle_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=5241e3dd5d3fa0b17dd6d6ea2f30734a32150c88$
-//
-
-extern (C):
-
-///
-// Callback for asynchronous continuation of cef_resource_handler_t::skip().
-///
-struct _cef_resource_skip_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Callback for asynchronous continuation of skip(). If |bytes_skipped| > 0
-    // then either skip() will be called again until the requested number of bytes
-    // have been skipped or the request will proceed. If |bytes_skipped| <= 0 the
-    // request will fail with ERR_REQUEST_RANGE_NOT_SATISFIABLE.
-    ///
-    void function (
-        _cef_resource_skip_callback_t* self,
-        int64 bytes_skipped) nothrow cont;
-}
-
-alias cef_resource_skip_callback_t = _cef_resource_skip_callback_t;
-
-///
-// Callback for asynchronous continuation of cef_resource_handler_t::read().
-///
-struct _cef_resource_read_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Callback for asynchronous continuation of read(). If |bytes_read| == 0 the
-    // response will be considered complete. If |bytes_read| > 0 then read() will
-    // be called again until the request is complete (based on either the result
-    // or the expected content length). If |bytes_read| < 0 then the request will
-    // fail and the |bytes_read| value will be treated as the error code.
-    ///
-    void function (_cef_resource_read_callback_t* self, int bytes_read) nothrow cont;
-}
-
-alias cef_resource_read_callback_t = _cef_resource_read_callback_t;
-
-///
-// Structure used to implement a custom request handler structure. The functions
-// of this structure will be called on the IO thread unless otherwise indicated.
-///
-struct _cef_resource_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Open the response stream. To handle the request immediately set
-    // |handle_request| to true (1) and return true (1). To decide at a later time
-    // set |handle_request| to false (0), return true (1), and execute |callback|
-    // to continue or cancel the request. To cancel the request immediately set
-    // |handle_request| to true (1) and return false (0). This function will be
-    // called in sequence but not from a dedicated thread. For backwards
-    // compatibility set |handle_request| to false (0) and return false (0) and
-    // the ProcessRequest function will be called.
-    ///
-    int function (
-        _cef_resource_handler_t* self,
-        _cef_request_t* request,
-        int* handle_request,
-        _cef_callback_t* callback) nothrow open;
-
-    ///
-    // Begin processing the request. To handle the request return true (1) and
-    // call cef_callback_t::cont() once the response header information is
-    // available (cef_callback_t::cont() can also be called from inside this
-    // function if header information is available immediately). To cancel the
-    // request return false (0).
-    //
-    // WARNING: This function is deprecated. Use Open instead.
-    ///
-    int function (
-        _cef_resource_handler_t* self,
-        _cef_request_t* request,
-        _cef_callback_t* callback) nothrow process_request;
-
-    ///
-    // Retrieve response header information. If the response length is not known
-    // set |response_length| to -1 and read_response() will be called until it
-    // returns false (0). If the response length is known set |response_length| to
-    // a positive value and read_response() will be called until it returns false
-    // (0) or the specified number of bytes have been read. Use the |response|
-    // object to set the mime type, http status code and other optional header
-    // values. To redirect the request to a new URL set |redirectUrl| to the new
-    // URL. |redirectUrl| can be either a relative or fully qualified URL. It is
-    // also possible to set |response| to a redirect http status code and pass the
-    // new URL via a Location header. Likewise with |redirectUrl| it is valid to
-    // set a relative or fully qualified URL as the Location header value. If an
-    // error occured while setting up the request you can call set_error() on
-    // |response| to indicate the error condition.
-    ///
-    void function (
-        _cef_resource_handler_t* self,
-        _cef_response_t* response,
-        int64* response_length,
-        cef_string_t* redirectUrl) nothrow get_response_headers;
-
-    ///
-    // Skip response data when requested by a Range header. Skip over and discard
-    // |bytes_to_skip| bytes of response data. If data is available immediately
-    // set |bytes_skipped| to the number of bytes skipped and return true (1). To
-    // read the data at a later time set |bytes_skipped| to 0, return true (1) and
-    // execute |callback| when the data is available. To indicate failure set
-    // |bytes_skipped| to < 0 (e.g. -2 for ERR_FAILED) and return false (0). This
-    // function will be called in sequence but not from a dedicated thread.
-    ///
-    int function (
-        _cef_resource_handler_t* self,
-        int64 bytes_to_skip,
-        int64* bytes_skipped,
-        _cef_resource_skip_callback_t* callback) nothrow skip;
-
-    ///
-    // Read response data. If data is available immediately copy up to
-    // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
-    // bytes copied, and return true (1). To read the data at a later time keep a
-    // pointer to |data_out|, set |bytes_read| to 0, return true (1) and execute
-    // |callback| when the data is available (|data_out| will remain valid until
-    // the callback is executed). To indicate response completion set |bytes_read|
-    // to 0 and return false (0). To indicate failure set |bytes_read| to < 0
-    // (e.g. -2 for ERR_FAILED) and return false (0). This function will be called
-    // in sequence but not from a dedicated thread. For backwards compatibility
-    // set |bytes_read| to -1 and return false (0) and the ReadResponse function
-    // will be called.
-    ///
-    int function (
-        _cef_resource_handler_t* self,
-        void* data_out,
-        int bytes_to_read,
-        int* bytes_read,
-        _cef_resource_read_callback_t* callback) nothrow read;
-
-    ///
-    // Read response data. If data is available immediately copy up to
-    // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
-    // bytes copied, and return true (1). To read the data at a later time set
-    // |bytes_read| to 0, return true (1) and call cef_callback_t::cont() when the
-    // data is available. To indicate response completion return false (0).
-    //
-    // WARNING: This function is deprecated. Use Skip and Read instead.
-    ///
-    int function (
-        _cef_resource_handler_t* self,
-        void* data_out,
-        int bytes_to_read,
-        int* bytes_read,
-        _cef_callback_t* callback) nothrow read_response;
-
-    ///
-    // Request processing has been canceled.
-    ///
-    void function (_cef_resource_handler_t* self) nothrow cancel;
-}
-
-alias cef_resource_handler_t = _cef_resource_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=afc96f188710bd336d09ce479a650aaa3a55357a$
-//
-
-extern (C):
-
-///
-// Implement this structure to handle events related to browser requests. The
-// functions of this structure will be called on the IO thread unless otherwise
-// indicated.
-///
-struct _cef_resource_request_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called on the IO thread before a resource request is loaded. The |browser|
-    // and |frame| values represent the source of the request, and may be NULL for
-    // requests originating from service workers or cef_urlrequest_t. To
-    // optionally filter cookies for the request return a
-    // cef_cookie_access_filter_t object. The |request| object cannot not be
-    // modified in this callback.
-    ///
-    _cef_cookie_access_filter_t* function (
-        _cef_resource_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request) nothrow get_cookie_access_filter;
-
-    ///
-    // Called on the IO thread before a resource request is loaded. The |browser|
-    // and |frame| values represent the source of the request, and may be NULL for
-    // requests originating from service workers or cef_urlrequest_t. To redirect
-    // or change the resource load optionally modify |request|. Modification of
-    // the request URL will be treated as a redirect. Return RV_CONTINUE to
-    // continue the request immediately. Return RV_CONTINUE_ASYNC and call
-    // cef_request_callback_t:: cont() at a later time to continue or cancel the
-    // request asynchronously. Return RV_CANCEL to cancel the request immediately.
-    //
-    ///
-    cef_return_value_t function (
-        _cef_resource_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        _cef_request_callback_t* callback) nothrow on_before_resource_load;
-
-    ///
-    // Called on the IO thread before a resource is loaded. The |browser| and
-    // |frame| values represent the source of the request, and may be NULL for
-    // requests originating from service workers or cef_urlrequest_t. To allow the
-    // resource to load using the default network loader return NULL. To specify a
-    // handler for the resource return a cef_resource_handler_t object. The
-    // |request| object cannot not be modified in this callback.
-    ///
-    _cef_resource_handler_t* function (
-        _cef_resource_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request) nothrow get_resource_handler;
-
-    ///
-    // Called on the IO thread when a resource load is redirected. The |browser|
-    // and |frame| values represent the source of the request, and may be NULL for
-    // requests originating from service workers or cef_urlrequest_t. The
-    // |request| parameter will contain the old URL and other request-related
-    // information. The |response| parameter will contain the response that
-    // resulted in the redirect. The |new_url| parameter will contain the new URL
-    // and can be changed if desired. The |request| and |response| objects cannot
-    // be modified in this callback.
-    ///
-    void function (
-        _cef_resource_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        _cef_response_t* response,
-        cef_string_t* new_url) nothrow on_resource_redirect;
-
-    ///
-    // Called on the IO thread when a resource response is received. The |browser|
-    // and |frame| values represent the source of the request, and may be NULL for
-    // requests originating from service workers or cef_urlrequest_t. To allow the
-    // resource load to proceed without modification return false (0). To redirect
-    // or retry the resource load optionally modify |request| and return true (1).
-    // Modification of the request URL will be treated as a redirect. Requests
-    // handled using the default network loader cannot be redirected in this
-    // callback. The |response| object cannot be modified in this callback.
-    //
-    // WARNING: Redirecting using this function is deprecated. Use
-    // OnBeforeResourceLoad or GetResourceHandler to perform redirects.
-    ///
-    int function (
-        _cef_resource_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        _cef_response_t* response) nothrow on_resource_response;
-
-    ///
-    // Called on the IO thread to optionally filter resource response content. The
-    // |browser| and |frame| values represent the source of the request, and may
-    // be NULL for requests originating from service workers or cef_urlrequest_t.
-    // |request| and |response| represent the request and response respectively
-    // and cannot be modified in this callback.
-    ///
-    _cef_response_filter_t* function (
-        _cef_resource_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        _cef_response_t* response) nothrow get_resource_response_filter;
-
-    ///
-    // Called on the IO thread when a resource load has completed. The |browser|
-    // and |frame| values represent the source of the request, and may be NULL for
-    // requests originating from service workers or cef_urlrequest_t. |request|
-    // and |response| represent the request and response respectively and cannot
-    // be modified in this callback. |status| indicates the load completion
-    // status. |received_content_length| is the number of response bytes actually
-    // read. This function will be called for all requests, including requests
-    // that are aborted due to CEF shutdown or destruction of the associated
-    // browser. In cases where the associated browser is destroyed this callback
-    // may arrive after the cef_life_span_handler_t::OnBeforeClose callback for
-    // that browser. The cef_frame_t::IsValid function can be used to test for
-    // this situation, and care should be taken not to call |browser| or |frame|
-    // functions that modify state (like LoadURL, SendProcessMessage, etc.) if the
-    // frame is invalid.
-    ///
-    void function (
-        _cef_resource_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        _cef_response_t* response,
-        cef_urlrequest_status_t status,
-        int64 received_content_length) nothrow on_resource_load_complete;
-
-    ///
-    // Called on the IO thread to handle requests for URLs with an unknown
-    // protocol component. The |browser| and |frame| values represent the source
-    // of the request, and may be NULL for requests originating from service
-    // workers or cef_urlrequest_t. |request| cannot be modified in this callback.
-    // Set |allow_os_execution| to true (1) to attempt execution via the
-    // registered OS protocol handler, if any. SECURITY WARNING: YOU SHOULD USE
-    // THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR OTHER URL
-    // ANALYSIS BEFORE ALLOWING OS EXECUTION.
-    ///
-    void function (
-        _cef_resource_request_handler_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        int* allow_os_execution) nothrow on_protocol_execution;
-}
-
-alias cef_resource_request_handler_t = _cef_resource_request_handler_t;
-
-///
-// Implement this structure to filter cookies that may be sent or received from
-// resource requests. The functions of this structure will be called on the IO
-// thread unless otherwise indicated.
-///
-struct _cef_cookie_access_filter_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called on the IO thread before a resource request is sent. The |browser|
-    // and |frame| values represent the source of the request, and may be NULL for
-    // requests originating from service workers or cef_urlrequest_t. |request|
-    // cannot be modified in this callback. Return true (1) if the specified
-    // cookie can be sent with the request or false (0) otherwise.
-    ///
-    int function (
-        _cef_cookie_access_filter_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        const(_cef_cookie_t)* cookie) nothrow can_send_cookie;
-
-    ///
-    // Called on the IO thread after a resource response is received. The
-    // |browser| and |frame| values represent the source of the request, and may
-    // be NULL for requests originating from service workers or cef_urlrequest_t.
-    // |request| cannot be modified in this callback. Return true (1) if the
-    // specified cookie returned with the response can be saved or false (0)
-    // otherwise.
-    ///
-    int function (
-        _cef_cookie_access_filter_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        _cef_request_t* request,
-        _cef_response_t* response,
-        const(_cef_cookie_t)* cookie) nothrow can_save_cookie;
-}
-
-alias cef_cookie_access_filter_t = _cef_cookie_access_filter_t;
-
-// CEF_INCLUDE_CAPI_CEF_RESOURCE_REQUEST_HANDLER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=2bccae35945ecea55c4c79bba840b44a691f1aa3$
-//
-
-extern (C):
-
-///
-// Structure used to represent a web response. The functions of this structure
-// may be called on any thread.
-///
-struct _cef_response_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is read-only.
-    ///
-    int function (_cef_response_t* self) nothrow is_read_only;
-
-    ///
-    // Get the response error code. Returns ERR_NONE if there was no error.
-    ///
-    cef_errorcode_t function (_cef_response_t* self) nothrow get_error;
-
-    ///
-    // Set the response error code. This can be used by custom scheme handlers to
-    // return errors during initial request processing.
-    ///
-    void function (_cef_response_t* self, cef_errorcode_t error) nothrow set_error;
-
-    ///
-    // Get the response status code.
-    ///
-    int function (_cef_response_t* self) nothrow get_status;
-
-    ///
-    // Set the response status code.
-    ///
-    void function (_cef_response_t* self, int status) nothrow set_status;
-
-    ///
-    // Get the response status text.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_response_t* self) nothrow get_status_text;
-
-    ///
-    // Set the response status text.
-    ///
-    void function (
-        _cef_response_t* self,
-        const(cef_string_t)* statusText) nothrow set_status_text;
-
-    ///
-    // Get the response mime type.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_response_t* self) nothrow get_mime_type;
-
-    ///
-    // Set the response mime type.
-    ///
-    void function (
-        _cef_response_t* self,
-        const(cef_string_t)* mimeType) nothrow set_mime_type;
-
-    ///
-    // Get the response charset.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_response_t* self) nothrow get_charset;
-
-    ///
-    // Set the response charset.
-    ///
-    void function (
-        _cef_response_t* self,
-        const(cef_string_t)* charset) nothrow set_charset;
-
-    ///
-    // Get the value for the specified response header field.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_response_t* self,
-        const(cef_string_t)* name) nothrow get_header_by_name;
-
-    ///
-    // Set the header |name| to |value|. If |overwrite| is true (1) any existing
-    // values will be replaced with the new value. If |overwrite| is false (0) any
-    // existing values will not be overwritten.
-    ///
-    void function (
-        _cef_response_t* self,
-        const(cef_string_t)* name,
-        const(cef_string_t)* value,
-        int overwrite) nothrow set_header_by_name;
-
-    ///
-    // Get all response header fields.
-    ///
-    void function (
-        _cef_response_t* self,
-        cef_string_multimap_t headerMap) nothrow get_header_map;
-
-    ///
-    // Set all response header fields.
-    ///
-    void function (
-        _cef_response_t* self,
-        cef_string_multimap_t headerMap) nothrow set_header_map;
-
-    ///
-    // Get the resolved URL after redirects or changed as a result of HSTS.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_response_t* self) nothrow get_url;
-
-    ///
-    // Set the resolved URL after redirects or changed as a result of HSTS.
-    ///
-    void function (_cef_response_t* self, const(cef_string_t)* url) nothrow set_url;
-}
-
-alias cef_response_t = _cef_response_t;
-
-///
-// Create a new cef_response_t object.
-///
-cef_response_t* cef_response_create ();
-
-// CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=5b2602702a13a71ac012808eecb09bb8b9494551$
-//
-
-extern (C):
-
-///
-// Implement this structure to filter resource response content. The functions
-// of this structure will be called on the browser process IO thread.
-///
-struct _cef_response_filter_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Initialize the response filter. Will only be called a single time. The
-    // filter will not be installed if this function returns false (0).
-    ///
-    int function (_cef_response_filter_t* self) nothrow init_filter;
-
-    ///
-    // Called to filter a chunk of data. Expected usage is as follows:
-    //
-    //  A. Read input data from |data_in| and set |data_in_read| to the number of
-    //     bytes that were read up to a maximum of |data_in_size|. |data_in| will
-    //     be NULL if |data_in_size| is zero.
-    //  B. Write filtered output data to |data_out| and set |data_out_written| to
-    //     the number of bytes that were written up to a maximum of
-    //     |data_out_size|. If no output data was written then all data must be
-    //     read from |data_in| (user must set |data_in_read| = |data_in_size|).
-    //  C. Return RESPONSE_FILTER_DONE if all output data was written or
-    //     RESPONSE_FILTER_NEED_MORE_DATA if output data is still pending.
-    //
-    // This function will be called repeatedly until the input buffer has been
-    // fully read (user sets |data_in_read| = |data_in_size|) and there is no more
-    // input data to filter (the resource response is complete). This function may
-    // then be called an additional time with an NULL input buffer if the user
-    // filled the output buffer (set |data_out_written| = |data_out_size|) and
-    // returned RESPONSE_FILTER_NEED_MORE_DATA to indicate that output data is
-    // still pending.
-    //
-    // Calls to this function will stop when one of the following conditions is
-    // met:
-    //
-    //  A. There is no more input data to filter (the resource response is
-    //     complete) and the user sets |data_out_written| = 0 or returns
-    //     RESPONSE_FILTER_DONE to indicate that all data has been written, or;
-    //  B. The user returns RESPONSE_FILTER_ERROR to indicate an error.
-    //
-    // Do not keep a reference to the buffers passed to this function.
-    ///
-    cef_response_filter_status_t function (
-        _cef_response_filter_t* self,
-        void* data_in,
-        size_t data_in_size,
-        size_t* data_in_read,
-        void* data_out,
-        size_t data_out_size,
-        size_t* data_out_written) nothrow filter;
-}
-
-alias cef_response_filter_t = _cef_response_filter_t;
-
-// CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=d93b4ad0b71ffe0a05326b39c3ed0bdb26a73fac$
-//
-
-extern (C):
-
-///
-// Structure that manages custom scheme registrations.
-///
-struct _cef_scheme_registrar_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_scoped_t base;
-
-    ///
-    // Register a custom scheme. This function should not be called for the built-
-    // in HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes.
-    //
-    // See cef_scheme_options_t for possible values for |options|.
-    //
-    // This function may be called on any thread. It should only be called once
-    // per unique |scheme_name| value. If |scheme_name| is already registered or
-    // if an error occurs this function will return false (0).
-    ///
-    int function (
-        _cef_scheme_registrar_t* self,
-        const(cef_string_t)* scheme_name,
-        int options) nothrow add_custom_scheme;
-}
-
-alias cef_scheme_registrar_t = _cef_scheme_registrar_t;
-
-///
-// Structure that creates cef_resource_handler_t instances for handling scheme
-// requests. The functions of this structure will always be called on the IO
-// thread.
-///
-struct _cef_scheme_handler_factory_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Return a new resource handler instance to handle the request or an NULL
-    // reference to allow default handling of the request. |browser| and |frame|
-    // will be the browser window and frame respectively that originated the
-    // request or NULL if the request did not originate from a browser window (for
-    // example, if the request came from cef_urlrequest_t). The |request| object
-    // passed to this function cannot be modified.
-    ///
-    _cef_resource_handler_t* function (
-        _cef_scheme_handler_factory_t* self,
-        _cef_browser_t* browser,
-        _cef_frame_t* frame,
-        const(cef_string_t)* scheme_name,
-        _cef_request_t* request) nothrow create;
-}
-
-alias cef_scheme_handler_factory_t = _cef_scheme_handler_factory_t;
-
-///
-// Register a scheme handler factory with the global request context. An NULL
-// |domain_name| value for a standard scheme will cause the factory to match all
-// domain names. The |domain_name| value will be ignored for non-standard
-// schemes. If |scheme_name| is a built-in scheme and no handler is returned by
-// |factory| then the built-in scheme handler factory will be called. If
-// |scheme_name| is a custom scheme then you must also implement the
-// cef_app_t::on_register_custom_schemes() function in all processes. This
-// function may be called multiple times to change or remove the factory that
-// matches the specified |scheme_name| and optional |domain_name|. Returns false
-// (0) if an error occurs. This function may be called on any thread in the
-// browser process. Using this function is equivalent to calling cef_request_con
-// text_t::cef_request_context_get_global_context()->register_scheme_handler_fac
-// tory().
-///
-int cef_register_scheme_handler_factory (
-    const(cef_string_t)* scheme_name,
-    const(cef_string_t)* domain_name,
-    cef_scheme_handler_factory_t* factory);
-
-///
-// Clear all scheme handler factories registered with the global request
-// context. Returns false (0) on error. This function may be called on any
-// thread in the browser process. Using this function is equivalent to calling c
-// ef_request_context_t::cef_request_context_get_global_context()->clear_scheme_
-// handler_factories().
-///
-int cef_clear_scheme_handler_factories ();
-
-// CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=ffd489adc301ed88e1f30f8f38cec1730411a4b5$
-//
-
-extern (C):
-
-///
-// Structure representing a server that supports HTTP and WebSocket requests.
-// Server capacity is limited and is intended to handle only a small number of
-// simultaneous connections (e.g. for communicating between applications on
-// localhost). The functions of this structure are safe to call from any thread
-// in the brower process unless otherwise indicated.
-///
-struct _cef_server_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the task runner for the dedicated server thread.
-    ///
-    _cef_task_runner_t* function (_cef_server_t* self) nothrow get_task_runner;
-
-    ///
-    // Stop the server and shut down the dedicated server thread. See
-    // cef_server_handler_t::OnServerCreated documentation for a description of
-    // server lifespan.
-    ///
-    void function (_cef_server_t* self) nothrow shutdown;
-
-    ///
-    // Returns true (1) if the server is currently running and accepting incoming
-    // connections. See cef_server_handler_t::OnServerCreated documentation for a
-    // description of server lifespan. This function must be called on the
-    // dedicated server thread.
-    ///
-    int function (_cef_server_t* self) nothrow is_running;
-
-    ///
-    // Returns the server address including the port number.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_server_t* self) nothrow get_address;
-
-    ///
-    // Returns true (1) if the server currently has a connection. This function
-    // must be called on the dedicated server thread.
-    ///
-    int function (_cef_server_t* self) nothrow has_connection;
-
-    ///
-    // Returns true (1) if |connection_id| represents a valid connection. This
-    // function must be called on the dedicated server thread.
-    ///
-    int function (_cef_server_t* self, int connection_id) nothrow is_valid_connection;
-
-    ///
-    // Send an HTTP 200 "OK" response to the connection identified by
-    // |connection_id|. |content_type| is the response content type (e.g.
-    // "text/html"), |data| is the response content, and |data_size| is the size
-    // of |data| in bytes. The contents of |data| will be copied. The connection
-    // will be closed automatically after the response is sent.
-    ///
-    void function (
-        _cef_server_t* self,
-        int connection_id,
-        const(cef_string_t)* content_type,
-        const(void)* data,
-        size_t data_size) nothrow send_http200response;
-
-    ///
-    // Send an HTTP 404 "Not Found" response to the connection identified by
-    // |connection_id|. The connection will be closed automatically after the
-    // response is sent.
-    ///
-    void function (
-        _cef_server_t* self,
-        int connection_id) nothrow send_http404response;
-
-    ///
-    // Send an HTTP 500 "Internal Server Error" response to the connection
-    // identified by |connection_id|. |error_message| is the associated error
-    // message. The connection will be closed automatically after the response is
-    // sent.
-    ///
-    void function (
-        _cef_server_t* self,
-        int connection_id,
-        const(cef_string_t)* error_message) nothrow send_http500response;
-
-    ///
-    // Send a custom HTTP response to the connection identified by
-    // |connection_id|. |response_code| is the HTTP response code sent in the
-    // status line (e.g. 200), |content_type| is the response content type sent as
-    // the "Content-Type" header (e.g. "text/html"), |content_length| is the
-    // expected content length, and |extra_headers| is the map of extra response
-    // headers. If |content_length| is >= 0 then the "Content-Length" header will
-    // be sent. If |content_length| is 0 then no content is expected and the
-    // connection will be closed automatically after the response is sent. If
-    // |content_length| is < 0 then no "Content-Length" header will be sent and
-    // the client will continue reading until the connection is closed. Use the
-    // SendRawData function to send the content, if applicable, and call
-    // CloseConnection after all content has been sent.
-    ///
-    void function (
-        _cef_server_t* self,
-        int connection_id,
-        int response_code,
-        const(cef_string_t)* content_type,
-        int64 content_length,
-        cef_string_multimap_t extra_headers) nothrow send_http_response;
-
-    ///
-    // Send raw data directly to the connection identified by |connection_id|.
-    // |data| is the raw data and |data_size| is the size of |data| in bytes. The
-    // contents of |data| will be copied. No validation of |data| is performed
-    // internally so the client should be careful to send the amount indicated by
-    // the "Content-Length" header, if specified. See SendHttpResponse
-    // documentation for intended usage.
-    ///
-    void function (
-        _cef_server_t* self,
-        int connection_id,
-        const(void)* data,
-        size_t data_size) nothrow send_raw_data;
-
-    ///
-    // Close the connection identified by |connection_id|. See SendHttpResponse
-    // documentation for intended usage.
-    ///
-    void function (_cef_server_t* self, int connection_id) nothrow close_connection;
-
-    ///
-    // Send a WebSocket message to the connection identified by |connection_id|.
-    // |data| is the response content and |data_size| is the size of |data| in
-    // bytes. The contents of |data| will be copied. See
-    // cef_server_handler_t::OnWebSocketRequest documentation for intended usage.
-    ///
-    void function (
-        _cef_server_t* self,
-        int connection_id,
-        const(void)* data,
-        size_t data_size) nothrow send_web_socket_message;
-}
-
-alias cef_server_t = _cef_server_t;
-
-///
-// Create a new server that binds to |address| and |port|. |address| must be a
-// valid IPv4 or IPv6 address (e.g. 127.0.0.1 or ::1) and |port| must be a port
-// number outside of the reserved range (e.g. between 1025 and 65535 on most
-// platforms). |backlog| is the maximum number of pending connections. A new
-// thread will be created for each CreateServer call (the "dedicated server
-// thread"). It is therefore recommended to use a different cef_server_handler_t
-// instance for each CreateServer call to avoid thread safety issues in the
-// cef_server_handler_t implementation. The
-// cef_server_handler_t::OnServerCreated function will be called on the
-// dedicated server thread to report success or failure. See
-// cef_server_handler_t::OnServerCreated documentation for a description of
-// server lifespan.
-///
-void cef_server_create (
-    const(cef_string_t)* address,
-    uint16 port,
-    int backlog,
-    _cef_server_handler_t* handler);
-
-///
-// Implement this structure to handle HTTP server requests. A new thread will be
-// created for each cef_server_t::CreateServer call (the "dedicated server
-// thread"), and the functions of this structure will be called on that thread.
-// It is therefore recommended to use a different cef_server_handler_t instance
-// for each cef_server_t::CreateServer call to avoid thread safety issues in the
-// cef_server_handler_t implementation.
-///
-struct _cef_server_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called when |server| is created. If the server was started successfully
-    // then cef_server_t::IsRunning will return true (1). The server will continue
-    // running until cef_server_t::Shutdown is called, after which time
-    // OnServerDestroyed will be called. If the server failed to start then
-    // OnServerDestroyed will be called immediately after this function returns.
-    ///
-    void function (
-        _cef_server_handler_t* self,
-        _cef_server_t* server) nothrow on_server_created;
-
-    ///
-    // Called when |server| is destroyed. The server thread will be stopped after
-    // this function returns. The client should release any references to |server|
-    // when this function is called. See OnServerCreated documentation for a
-    // description of server lifespan.
-    ///
-    void function (
-        _cef_server_handler_t* self,
-        _cef_server_t* server) nothrow on_server_destroyed;
-
-    ///
-    // Called when a client connects to |server|. |connection_id| uniquely
-    // identifies the connection. Each call to this function will have a matching
-    // call to OnClientDisconnected.
-    ///
-    void function (
-        _cef_server_handler_t* self,
-        _cef_server_t* server,
-        int connection_id) nothrow on_client_connected;
-
-    ///
-    // Called when a client disconnects from |server|. |connection_id| uniquely
-    // identifies the connection. The client should release any data associated
-    // with |connection_id| when this function is called and |connection_id|
-    // should no longer be passed to cef_server_t functions. Disconnects can
-    // originate from either the client or the server. For example, the server
-    // will disconnect automatically after a cef_server_t::SendHttpXXXResponse
-    // function is called.
-    ///
-    void function (
-        _cef_server_handler_t* self,
-        _cef_server_t* server,
-        int connection_id) nothrow on_client_disconnected;
-
-    ///
-    // Called when |server| receives an HTTP request. |connection_id| uniquely
-    // identifies the connection, |client_address| is the requesting IPv4 or IPv6
-    // client address including port number, and |request| contains the request
-    // contents (URL, function, headers and optional POST data). Call cef_server_t
-    // functions either synchronously or asynchronusly to send a response.
-    ///
-    void function (
-        _cef_server_handler_t* self,
-        _cef_server_t* server,
-        int connection_id,
-        const(cef_string_t)* client_address,
-        _cef_request_t* request) nothrow on_http_request;
-
-    ///
-    // Called when |server| receives a WebSocket request. |connection_id| uniquely
-    // identifies the connection, |client_address| is the requesting IPv4 or IPv6
-    // client address including port number, and |request| contains the request
-    // contents (URL, function, headers and optional POST data). Execute
-    // |callback| either synchronously or asynchronously to accept or decline the
-    // WebSocket connection. If the request is accepted then OnWebSocketConnected
-    // will be called after the WebSocket has connected and incoming messages will
-    // be delivered to the OnWebSocketMessage callback. If the request is declined
-    // then the client will be disconnected and OnClientDisconnected will be
-    // called. Call the cef_server_t::SendWebSocketMessage function after
-    // receiving the OnWebSocketConnected callback to respond with WebSocket
-    // messages.
-    ///
-    void function (
-        _cef_server_handler_t* self,
-        _cef_server_t* server,
-        int connection_id,
-        const(cef_string_t)* client_address,
-        _cef_request_t* request,
-        _cef_callback_t* callback) nothrow on_web_socket_request;
-
-    ///
-    // Called after the client has accepted the WebSocket connection for |server|
-    // and |connection_id| via the OnWebSocketRequest callback. See
-    // OnWebSocketRequest documentation for intended usage.
-    ///
-    void function (
-        _cef_server_handler_t* self,
-        _cef_server_t* server,
-        int connection_id) nothrow on_web_socket_connected;
-
-    ///
-    // Called when |server| receives an WebSocket message. |connection_id|
-    // uniquely identifies the connection, |data| is the message content and
-    // |data_size| is the size of |data| in bytes. Do not keep a reference to
-    // |data| outside of this function. See OnWebSocketRequest documentation for
-    // intended usage.
-    ///
-    void function (
-        _cef_server_handler_t* self,
-        _cef_server_t* server,
-        int connection_id,
-        const(void)* data,
-        size_t data_size) nothrow on_web_socket_message;
-}
-
-alias cef_server_handler_t = _cef_server_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_SERVER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=badaadcff4641fea876fb626b8ffe5a6f34a376c$
-//
-
-extern (C):
-
-///
-// Structure representing SSL information.
-///
-struct _cef_sslinfo_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns a bitmask containing any and all problems verifying the server
-    // certificate.
-    ///
-    cef_cert_status_t function (_cef_sslinfo_t* self) nothrow get_cert_status;
-
-    ///
-    // Returns the X.509 certificate.
-    ///
-    _cef_x509certificate_t* function (
-        _cef_sslinfo_t* self) nothrow get_x509certificate;
-}
-
-alias cef_sslinfo_t = _cef_sslinfo_t;
-
-///
-// Returns true (1) if the certificate status represents an error.
-///
-int cef_is_cert_status_error (cef_cert_status_t status);
-
-// CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=3755121a7b89de52a67885ac1c6d12de23f4b657$
-//
-
-extern (C):
-
-///
-// Structure representing the SSL information for a navigation entry.
-///
-struct _cef_sslstatus_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if the status is related to a secure SSL/TLS connection.
-    ///
-    int function (_cef_sslstatus_t* self) nothrow is_secure_connection;
-
-    ///
-    // Returns a bitmask containing any and all problems verifying the server
-    // certificate.
-    ///
-    cef_cert_status_t function (_cef_sslstatus_t* self) nothrow get_cert_status;
-
-    ///
-    // Returns the SSL version used for the SSL connection.
-    ///
-    cef_ssl_version_t function (_cef_sslstatus_t* self) nothrow get_sslversion;
-
-    ///
-    // Returns a bitmask containing the page security content status.
-    ///
-    cef_ssl_content_status_t function (
-        _cef_sslstatus_t* self) nothrow get_content_status;
-
-    ///
-    // Returns the X.509 certificate.
-    ///
-    _cef_x509certificate_t* function (
-        _cef_sslstatus_t* self) nothrow get_x509certificate;
-}
-
-alias cef_sslstatus_t = _cef_sslstatus_t;
-
-// CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=bd5bbcdc385f83512bf64304e180f1a05b765c16$
-//
-
-extern (C):
-
-///
-// Structure the client can implement to provide a custom stream reader. The
-// functions of this structure may be called on any thread.
-///
-struct _cef_read_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Read raw binary data.
-    ///
-    size_t function (
-        _cef_read_handler_t* self,
-        void* ptr,
-        size_t size,
-        size_t n) nothrow read;
-
-    ///
-    // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
-    // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
-    ///
-    int function (_cef_read_handler_t* self, int64 offset, int whence) nothrow seek;
-
-    ///
-    // Return the current offset position.
-    ///
-    int64 function (_cef_read_handler_t* self) nothrow tell;
-
-    ///
-    // Return non-zero if at end of file.
-    ///
-    int function (_cef_read_handler_t* self) nothrow eof;
-
-    ///
-    // Return true (1) if this handler performs work like accessing the file
-    // system which may block. Used as a hint for determining the thread to access
-    // the handler from.
-    ///
-    int function (_cef_read_handler_t* self) nothrow may_block;
-}
-
-alias cef_read_handler_t = _cef_read_handler_t;
-
-///
-// Structure used to read data from a stream. The functions of this structure
-// may be called on any thread.
-///
-struct _cef_stream_reader_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Read raw binary data.
-    ///
-    size_t function (
-        _cef_stream_reader_t* self,
-        void* ptr,
-        size_t size,
-        size_t n) nothrow read;
-
-    ///
-    // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
-    // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
-    ///
-    int function (_cef_stream_reader_t* self, int64 offset, int whence) nothrow seek;
-
-    ///
-    // Return the current offset position.
-    ///
-    int64 function (_cef_stream_reader_t* self) nothrow tell;
-
-    ///
-    // Return non-zero if at end of file.
-    ///
-    int function (_cef_stream_reader_t* self) nothrow eof;
-
-    ///
-    // Returns true (1) if this reader performs work like accessing the file
-    // system which may block. Used as a hint for determining the thread to access
-    // the reader from.
-    ///
-    int function (_cef_stream_reader_t* self) nothrow may_block;
-}
-
-alias cef_stream_reader_t = _cef_stream_reader_t;
-
-///
-// Create a new cef_stream_reader_t object from a file.
-///
-cef_stream_reader_t* cef_stream_reader_create_for_file (
-    const(cef_string_t)* fileName);
-
-///
-// Create a new cef_stream_reader_t object from data.
-///
-cef_stream_reader_t* cef_stream_reader_create_for_data (
-    void* data,
-    size_t size);
-
-///
-// Create a new cef_stream_reader_t object from a custom handler.
-///
-cef_stream_reader_t* cef_stream_reader_create_for_handler (
-    cef_read_handler_t* handler);
-
-///
-// Structure the client can implement to provide a custom stream writer. The
-// functions of this structure may be called on any thread.
-///
-struct _cef_write_handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Write raw binary data.
-    ///
-    size_t function (
-        _cef_write_handler_t* self,
-        const(void)* ptr,
-        size_t size,
-        size_t n) nothrow write;
-
-    ///
-    // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
-    // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
-    ///
-    int function (_cef_write_handler_t* self, int64 offset, int whence) nothrow seek;
-
-    ///
-    // Return the current offset position.
-    ///
-    int64 function (_cef_write_handler_t* self) nothrow tell;
-
-    ///
-    // Flush the stream.
-    ///
-    int function (_cef_write_handler_t* self) nothrow flush;
-
-    ///
-    // Return true (1) if this handler performs work like accessing the file
-    // system which may block. Used as a hint for determining the thread to access
-    // the handler from.
-    ///
-    int function (_cef_write_handler_t* self) nothrow may_block;
-}
-
-alias cef_write_handler_t = _cef_write_handler_t;
-
-///
-// Structure used to write data to a stream. The functions of this structure may
-// be called on any thread.
-///
-struct _cef_stream_writer_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Write raw binary data.
-    ///
-    size_t function (
-        _cef_stream_writer_t* self,
-        const(void)* ptr,
-        size_t size,
-        size_t n) nothrow write;
-
-    ///
-    // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
-    // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
-    ///
-    int function (_cef_stream_writer_t* self, int64 offset, int whence) nothrow seek;
-
-    ///
-    // Return the current offset position.
-    ///
-    int64 function (_cef_stream_writer_t* self) nothrow tell;
-
-    ///
-    // Flush the stream.
-    ///
-    int function (_cef_stream_writer_t* self) nothrow flush;
-
-    ///
-    // Returns true (1) if this writer performs work like accessing the file
-    // system which may block. Used as a hint for determining the thread to access
-    // the writer from.
-    ///
-    int function (_cef_stream_writer_t* self) nothrow may_block;
-}
-
-alias cef_stream_writer_t = _cef_stream_writer_t;
-
-///
-// Create a new cef_stream_writer_t object for a file.
-///
-cef_stream_writer_t* cef_stream_writer_create_for_file (
-    const(cef_string_t)* fileName);
-
-///
-// Create a new cef_stream_writer_t object for a custom handler.
-///
-cef_stream_writer_t* cef_stream_writer_create_for_handler (
-    cef_write_handler_t* handler);
-
-// CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=bba3a9719860f9a81c63cbb052a4c501416b2ada$
-//
-
-extern (C):
-
-///
-// Implement this structure to receive string values asynchronously.
-///
-struct _cef_string_visitor_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be executed.
-    ///
-    void function (
-        _cef_string_visitor_t* self,
-        const(cef_string_t)* string) nothrow visit;
-}
-
-alias cef_string_visitor_t = _cef_string_visitor_t;
-
-// CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=025daa5db3bf16029953da7703e3e5968bd97fe2$
-//
-
-extern (C):
-
-///
-// Implement this structure for asynchronous task execution. If the task is
-// posted successfully and if the associated message loop is still running then
-// the execute() function will be called on the target thread. If the task fails
-// to post then the task object may be destroyed on the source thread instead of
-// the target thread. For this reason be cautious when performing work in the
-// task object destructor.
-///
-struct _cef_task_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be executed on the target thread.
-    ///
-    void function (_cef_task_t* self) nothrow execute;
-}
-
-alias cef_task_t = _cef_task_t;
-
-///
-// Structure that asynchronously executes tasks on the associated thread. It is
-// safe to call the functions of this structure on any thread.
-//
-// CEF maintains multiple internal threads that are used for handling different
-// types of tasks in different processes. The cef_thread_id_t definitions in
-// cef_types.h list the common CEF threads. Task runners are also available for
-// other CEF threads as appropriate (for example, V8 WebWorker threads).
-///
-struct _cef_task_runner_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is pointing to the same task runner as
-    // |that| object.
-    ///
-    int function (_cef_task_runner_t* self, _cef_task_runner_t* that) nothrow is_same;
-
-    ///
-    // Returns true (1) if this task runner belongs to the current thread.
-    ///
-    int function (_cef_task_runner_t* self) nothrow belongs_to_current_thread;
-
-    ///
-    // Returns true (1) if this task runner is for the specified CEF thread.
-    ///
-    int function (
-        _cef_task_runner_t* self,
-        cef_thread_id_t threadId) nothrow belongs_to_thread;
-
-    ///
-    // Post a task for execution on the thread associated with this task runner.
-    // Execution will occur asynchronously.
-    ///
-    int function (_cef_task_runner_t* self, _cef_task_t* task) nothrow post_task;
-
-    ///
-    // Post a task for delayed execution on the thread associated with this task
-    // runner. Execution will occur asynchronously. Delayed tasks are not
-    // supported on V8 WebWorker threads and will be executed without the
-    // specified delay.
-    ///
-    int function (
-        _cef_task_runner_t* self,
-        _cef_task_t* task,
-        int64 delay_ms) nothrow post_delayed_task;
-}
-
-alias cef_task_runner_t = _cef_task_runner_t;
-
-///
-// Returns the task runner for the current thread. Only CEF threads will have
-// task runners. An NULL reference will be returned if this function is called
-// on an invalid thread.
-///
-cef_task_runner_t* cef_task_runner_get_for_current_thread ();
-
-///
-// Returns the task runner for the specified CEF thread.
-///
-cef_task_runner_t* cef_task_runner_get_for_thread (cef_thread_id_t threadId);
-
-///
-// Returns true (1) if called on the specified thread. Equivalent to using
-// cef_task_runner_t::GetForThread(threadId)->belongs_to_current_thread().
-///
-int cef_currently_on (cef_thread_id_t threadId);
-
-///
-// Post a task for execution on the specified thread. Equivalent to using
-// cef_task_runner_t::GetForThread(threadId)->PostTask(task).
-///
-int cef_post_task (cef_thread_id_t threadId, cef_task_t* task);
-
-///
-// Post a task for delayed execution on the specified thread. Equivalent to
-// using cef_task_runner_t::GetForThread(threadId)->PostDelayedTask(task,
-// delay_ms).
-///
-int cef_post_delayed_task (
-    cef_thread_id_t threadId,
-    cef_task_t* task,
-    int64 delay_ms);
-
-// CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=d443c0990241554b548bc946f46f35582445e818$
-//
-
-extern (C):
-
-///
-// A simple thread abstraction that establishes a message loop on a new thread.
-// The consumer uses cef_task_runner_t to execute code on the thread's message
-// loop. The thread is terminated when the cef_thread_t object is destroyed or
-// stop() is called. All pending tasks queued on the thread's message loop will
-// run to completion before the thread is terminated. cef_thread_create() can be
-// called on any valid CEF thread in either the browser or render process. This
-// structure should only be used for tasks that require a dedicated thread. In
-// most cases you can post tasks to an existing CEF thread instead of creating a
-// new one; see cef_task.h for details.
-///
-struct _cef_thread_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the cef_task_runner_t that will execute code on this thread's
-    // message loop. This function is safe to call from any thread.
-    ///
-    _cef_task_runner_t* function (_cef_thread_t* self) nothrow get_task_runner;
-
-    ///
-    // Returns the platform thread ID. It will return the same value after stop()
-    // is called. This function is safe to call from any thread.
-    ///
-    cef_platform_thread_id_t function (
-        _cef_thread_t* self) nothrow get_platform_thread_id;
-
-    ///
-    // Stop and join the thread. This function must be called from the same thread
-    // that called cef_thread_create(). Do not call this function if
-    // cef_thread_create() was called with a |stoppable| value of false (0).
-    ///
-    void function (_cef_thread_t* self) nothrow stop;
-
-    ///
-    // Returns true (1) if the thread is currently running. This function must be
-    // called from the same thread that called cef_thread_create().
-    ///
-    int function (_cef_thread_t* self) nothrow is_running;
-}
-
-alias cef_thread_t = _cef_thread_t;
-
-///
-// Create and start a new thread. This function does not block waiting for the
-// thread to run initialization. |display_name| is the name that will be used to
-// identify the thread. |priority| is the thread execution priority.
-// |message_loop_type| indicates the set of asynchronous events that the thread
-// can process. If |stoppable| is true (1) the thread will stopped and joined on
-// destruction or when stop() is called; otherwise, the thread cannot be stopped
-// and will be leaked on shutdown. On Windows the |com_init_mode| value
-// specifies how COM will be initialized for the thread. If |com_init_mode| is
-// set to COM_INIT_MODE_STA then |message_loop_type| must be set to ML_TYPE_UI.
-///
-cef_thread_t* cef_thread_create (
-    const(cef_string_t)* display_name,
-    cef_thread_priority_t priority,
-    cef_message_loop_type_t message_loop_type,
-    int stoppable,
-    cef_com_init_mode_t com_init_mode);
-
-// CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=b1b96b7cb636afbd201b88bc1544afc58099c0b6$
-//
-
-extern (C):
-
-///
-// Implement this structure to receive notification when tracing has completed.
-// The functions of this structure will be called on the browser process UI
-// thread.
-///
-struct _cef_end_tracing_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called after all processes have sent their trace data. |tracing_file| is
-    // the path at which tracing data was written. The client is responsible for
-    // deleting |tracing_file|.
-    ///
-    void function (
-        _cef_end_tracing_callback_t* self,
-        const(cef_string_t)* tracing_file) nothrow on_end_tracing_complete;
-}
-
-alias cef_end_tracing_callback_t = _cef_end_tracing_callback_t;
-
-///
-// Start tracing events on all processes. Tracing is initialized asynchronously
-// and |callback| will be executed on the UI thread after initialization is
-// complete.
-//
-// If CefBeginTracing was called previously, or if a CefEndTracingAsync call is
-// pending, CefBeginTracing will fail and return false (0).
-//
-// |categories| is a comma-delimited list of category wildcards. A category can
-// have an optional '-' prefix to make it an excluded category. Having both
-// included and excluded categories in the same list is not supported.
-//
-// Example: "test_MyTest*" Example: "test_MyTest*,test_OtherStuff" Example:
-// "-excluded_category1,-excluded_category2"
-//
-// This function must be called on the browser process UI thread.
-///
-int cef_begin_tracing (
-    const(cef_string_t)* categories,
-    _cef_completion_callback_t* callback);
-
-///
-// Stop tracing events on all processes.
-//
-// This function will fail and return false (0) if a previous call to
-// CefEndTracingAsync is already pending or if CefBeginTracing was not called.
-//
-// |tracing_file| is the path at which tracing data will be written and
-// |callback| is the callback that will be executed once all processes have sent
-// their trace data. If |tracing_file| is NULL a new temporary file path will be
-// used. If |callback| is NULL no trace data will be written.
-//
-// This function must be called on the browser process UI thread.
-///
-int cef_end_tracing (
-    const(cef_string_t)* tracing_file,
-    cef_end_tracing_callback_t* callback);
-
-///
-// Returns the current system trace time or, if none is defined, the current
-// high-res time. Can be used by clients to synchronize with the time
-// information in trace events.
-///
-int64 cef_now_from_system_trace_time ();
-
-// CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=75f4f7a9ff628a6ae699a697722caa5d49546784$
-//
-
-extern (C):
-
-///
-// Structure used to make a URL request. URL requests are not associated with a
-// browser instance so no cef_client_t callbacks will be executed. URL requests
-// can be created on any valid CEF thread in either the browser or render
-// process. Once created the functions of the URL request object must be
-// accessed on the same thread that created it.
-///
-struct _cef_urlrequest_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the request object used to create this URL request. The returned
-    // object is read-only and should not be modified.
-    ///
-    _cef_request_t* function (_cef_urlrequest_t* self) nothrow get_request;
-
-    ///
-    // Returns the client.
-    ///
-    _cef_urlrequest_client_t* function (_cef_urlrequest_t* self) nothrow get_client;
-
-    ///
-    // Returns the request status.
-    ///
-    cef_urlrequest_status_t function (
-        _cef_urlrequest_t* self) nothrow get_request_status;
-
-    ///
-    // Returns the request error if status is UR_CANCELED or UR_FAILED, or 0
-    // otherwise.
-    ///
-    cef_errorcode_t function (_cef_urlrequest_t* self) nothrow get_request_error;
-
-    ///
-    // Returns the response, or NULL if no response information is available.
-    // Response information will only be available after the upload has completed.
-    // The returned object is read-only and should not be modified.
-    ///
-    _cef_response_t* function (_cef_urlrequest_t* self) nothrow get_response;
-
-    ///
-    // Returns true (1) if the response body was served from the cache. This
-    // includes responses for which revalidation was required.
-    ///
-    int function (_cef_urlrequest_t* self) nothrow response_was_cached;
-
-    ///
-    // Cancel the request.
-    ///
-    void function (_cef_urlrequest_t* self) nothrow cancel;
-}
-
-alias cef_urlrequest_t = _cef_urlrequest_t;
-
-///
-// Create a new URL request that is not associated with a specific browser or
-// frame. Use cef_frame_t::CreateURLRequest instead if you want the request to
-// have this association, in which case it may be handled differently (see
-// documentation on that function). A request created with this function may
-// only originate from the browser process, and will behave as follows:
-//   - It may be intercepted by the client via CefResourceRequestHandler or
-//     CefSchemeHandlerFactory.
-//   - POST data may only contain only a single element of type PDE_TYPE_FILE
-//     or PDE_TYPE_BYTES.
-//   - If |request_context| is empty the global request context will be used.
-//
-// The |request| object will be marked as read-only after calling this function.
-///
-cef_urlrequest_t* cef_urlrequest_create (
-    _cef_request_t* request,
-    _cef_urlrequest_client_t* client,
-    _cef_request_context_t* request_context);
-
-///
-// Structure that should be implemented by the cef_urlrequest_t client. The
-// functions of this structure will be called on the same thread that created
-// the request unless otherwise documented.
-///
-struct _cef_urlrequest_client_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Notifies the client that the request has completed. Use the
-    // cef_urlrequest_t::GetRequestStatus function to determine if the request was
-    // successful or not.
-    ///
-    void function (
-        _cef_urlrequest_client_t* self,
-        _cef_urlrequest_t* request) nothrow on_request_complete;
-
-    ///
-    // Notifies the client of upload progress. |current| denotes the number of
-    // bytes sent so far and |total| is the total size of uploading data (or -1 if
-    // chunked upload is enabled). This function will only be called if the
-    // UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.
-    ///
-    void function (
-        _cef_urlrequest_client_t* self,
-        _cef_urlrequest_t* request,
-        int64 current,
-        int64 total) nothrow on_upload_progress;
-
-    ///
-    // Notifies the client of download progress. |current| denotes the number of
-    // bytes received up to the call and |total| is the expected total size of the
-    // response (or -1 if not determined).
-    ///
-    void function (
-        _cef_urlrequest_client_t* self,
-        _cef_urlrequest_t* request,
-        int64 current,
-        int64 total) nothrow on_download_progress;
-
-    ///
-    // Called when some part of the response is read. |data| contains the current
-    // bytes received since the last call. This function will not be called if the
-    // UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request.
-    ///
-    void function (
-        _cef_urlrequest_client_t* self,
-        _cef_urlrequest_t* request,
-        const(void)* data,
-        size_t data_length) nothrow on_download_data;
-
-    ///
-    // Called on the IO thread when the browser needs credentials from the user.
-    // |isProxy| indicates whether the host is a proxy server. |host| contains the
-    // hostname and |port| contains the port number. Return true (1) to continue
-    // the request and call cef_auth_callback_t::cont() when the authentication
-    // information is available. If the request has an associated browser/frame
-    // then returning false (0) will result in a call to GetAuthCredentials on the
-    // cef_request_handler_t associated with that browser, if any. Otherwise,
-    // returning false (0) will cancel the request immediately. This function will
-    // only be called for requests initiated from the browser process.
-    ///
-    int function (
-        _cef_urlrequest_client_t* self,
-        int isProxy,
-        const(cef_string_t)* host,
-        int port,
-        const(cef_string_t)* realm,
-        const(cef_string_t)* scheme,
-        _cef_auth_callback_t* callback) nothrow get_auth_credentials;
-}
-
-alias cef_urlrequest_client_t = _cef_urlrequest_client_t;
-
-// CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=3bb8f9801a153172981120926c7a5629e08d7131$
-//
-
-extern (C):
-
-///
-// Structure representing a V8 context handle. V8 handles can only be accessed
-// from the thread on which they are created. Valid threads for creating a V8
-// handle include the render process main thread (TID_RENDERER) and WebWorker
-// threads. A task runner for posting tasks on the associated thread can be
-// retrieved via the cef_v8context_t::get_task_runner() function.
-///
-struct _cef_v8context_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the task runner associated with this context. V8 handles can only
-    // be accessed from the thread on which they are created. This function can be
-    // called on any render process thread.
-    ///
-    _cef_task_runner_t* function (_cef_v8context_t* self) nothrow get_task_runner;
-
-    ///
-    // Returns true (1) if the underlying handle is valid and it can be accessed
-    // on the current thread. Do not call any other functions if this function
-    // returns false (0).
-    ///
-    int function (_cef_v8context_t* self) nothrow is_valid;
-
-    ///
-    // Returns the browser for this context. This function will return an NULL
-    // reference for WebWorker contexts.
-    ///
-    _cef_browser_t* function (_cef_v8context_t* self) nothrow get_browser;
-
-    ///
-    // Returns the frame for this context. This function will return an NULL
-    // reference for WebWorker contexts.
-    ///
-    _cef_frame_t* function (_cef_v8context_t* self) nothrow get_frame;
-
-    ///
-    // Returns the global object for this context. The context must be entered
-    // before calling this function.
-    ///
-    _cef_v8value_t* function (_cef_v8context_t* self) nothrow get_global;
-
-    ///
-    // Enter this context. A context must be explicitly entered before creating a
-    // V8 Object, Array, Function or Date asynchronously. exit() must be called
-    // the same number of times as enter() before releasing this context. V8
-    // objects belong to the context in which they are created. Returns true (1)
-    // if the scope was entered successfully.
-    ///
-    int function (_cef_v8context_t* self) nothrow enter;
-
-    ///
-    // Exit this context. Call this function only after calling enter(). Returns
-    // true (1) if the scope was exited successfully.
-    ///
-    int function (_cef_v8context_t* self) nothrow exit;
-
-    ///
-    // Returns true (1) if this object is pointing to the same handle as |that|
-    // object.
-    ///
-    int function (_cef_v8context_t* self, _cef_v8context_t* that) nothrow is_same;
-
-    ///
-    // Execute a string of JavaScript code in this V8 context. The |script_url|
-    // parameter is the URL where the script in question can be found, if any. The
-    // |start_line| parameter is the base line number to use for error reporting.
-    // On success |retval| will be set to the return value, if any, and the
-    // function will return true (1). On failure |exception| will be set to the
-    // exception, if any, and the function will return false (0).
-    ///
-    int function (
-        _cef_v8context_t* self,
-        const(cef_string_t)* code,
-        const(cef_string_t)* script_url,
-        int start_line,
-        _cef_v8value_t** retval,
-        _cef_v8exception_t** exception) nothrow eval;
-}
-
-alias cef_v8context_t = _cef_v8context_t;
-
-///
-// Returns the current (top) context object in the V8 context stack.
-///
-cef_v8context_t* cef_v8context_get_current_context ();
-
-///
-// Returns the entered (bottom) context object in the V8 context stack.
-///
-cef_v8context_t* cef_v8context_get_entered_context ();
-
-///
-// Returns true (1) if V8 is currently inside a context.
-///
-int cef_v8context_in_context ();
-
-///
-// Structure that should be implemented to handle V8 function calls. The
-// functions of this structure will be called on the thread associated with the
-// V8 function.
-///
-struct _cef_v8handler_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Handle execution of the function identified by |name|. |object| is the
-    // receiver ('this' object) of the function. |arguments| is the list of
-    // arguments passed to the function. If execution succeeds set |retval| to the
-    // function return value. If execution fails set |exception| to the exception
-    // that will be thrown. Return true (1) if execution was handled.
-    ///
-    int function (
-        _cef_v8handler_t* self,
-        const(cef_string_t)* name,
-        _cef_v8value_t* object,
-        size_t argumentsCount,
-        _cef_v8value_t** arguments,
-        _cef_v8value_t** retval,
-        cef_string_t* exception) nothrow execute;
-}
-
-alias cef_v8handler_t = _cef_v8handler_t;
-
-///
-// Structure that should be implemented to handle V8 accessor calls. Accessor
-// identifiers are registered by calling cef_v8value_t::set_value(). The
-// functions of this structure will be called on the thread associated with the
-// V8 accessor.
-///
-struct _cef_v8accessor_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Handle retrieval the accessor value identified by |name|. |object| is the
-    // receiver ('this' object) of the accessor. If retrieval succeeds set
-    // |retval| to the return value. If retrieval fails set |exception| to the
-    // exception that will be thrown. Return true (1) if accessor retrieval was
-    // handled.
-    ///
-    int function (
-        _cef_v8accessor_t* self,
-        const(cef_string_t)* name,
-        _cef_v8value_t* object,
-        _cef_v8value_t** retval,
-        cef_string_t* exception) nothrow get;
-
-    ///
-    // Handle assignment of the accessor value identified by |name|. |object| is
-    // the receiver ('this' object) of the accessor. |value| is the new value
-    // being assigned to the accessor. If assignment fails set |exception| to the
-    // exception that will be thrown. Return true (1) if accessor assignment was
-    // handled.
-    ///
-    int function (
-        _cef_v8accessor_t* self,
-        const(cef_string_t)* name,
-        _cef_v8value_t* object,
-        _cef_v8value_t* value,
-        cef_string_t* exception) nothrow set;
-}
-
-alias cef_v8accessor_t = _cef_v8accessor_t;
-
-///
-// Structure that should be implemented to handle V8 interceptor calls. The
-// functions of this structure will be called on the thread associated with the
-// V8 interceptor. Interceptor's named property handlers (with first argument of
-// type CefString) are called when object is indexed by string. Indexed property
-// handlers (with first argument of type int) are called when object is indexed
-// by integer.
-///
-struct _cef_v8interceptor_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Handle retrieval of the interceptor value identified by |name|. |object| is
-    // the receiver ('this' object) of the interceptor. If retrieval succeeds, set
-    // |retval| to the return value. If the requested value does not exist, don't
-    // set either |retval| or |exception|. If retrieval fails, set |exception| to
-    // the exception that will be thrown. If the property has an associated
-    // accessor, it will be called only if you don't set |retval|. Return true (1)
-    // if interceptor retrieval was handled, false (0) otherwise.
-    ///
-    int function (
-        _cef_v8interceptor_t* self,
-        const(cef_string_t)* name,
-        _cef_v8value_t* object,
-        _cef_v8value_t** retval,
-        cef_string_t* exception) nothrow get_byname;
-
-    ///
-    // Handle retrieval of the interceptor value identified by |index|. |object|
-    // is the receiver ('this' object) of the interceptor. If retrieval succeeds,
-    // set |retval| to the return value. If the requested value does not exist,
-    // don't set either |retval| or |exception|. If retrieval fails, set
-    // |exception| to the exception that will be thrown. Return true (1) if
-    // interceptor retrieval was handled, false (0) otherwise.
-    ///
-    int function (
-        _cef_v8interceptor_t* self,
-        int index,
-        _cef_v8value_t* object,
-        _cef_v8value_t** retval,
-        cef_string_t* exception) nothrow get_byindex;
-
-    ///
-    // Handle assignment of the interceptor value identified by |name|. |object|
-    // is the receiver ('this' object) of the interceptor. |value| is the new
-    // value being assigned to the interceptor. If assignment fails, set
-    // |exception| to the exception that will be thrown. This setter will always
-    // be called, even when the property has an associated accessor. Return true
-    // (1) if interceptor assignment was handled, false (0) otherwise.
-    ///
-    int function (
-        _cef_v8interceptor_t* self,
-        const(cef_string_t)* name,
-        _cef_v8value_t* object,
-        _cef_v8value_t* value,
-        cef_string_t* exception) nothrow set_byname;
-
-    ///
-    // Handle assignment of the interceptor value identified by |index|. |object|
-    // is the receiver ('this' object) of the interceptor. |value| is the new
-    // value being assigned to the interceptor. If assignment fails, set
-    // |exception| to the exception that will be thrown. Return true (1) if
-    // interceptor assignment was handled, false (0) otherwise.
-    ///
-    int function (
-        _cef_v8interceptor_t* self,
-        int index,
-        _cef_v8value_t* object,
-        _cef_v8value_t* value,
-        cef_string_t* exception) nothrow set_byindex;
-}
-
-alias cef_v8interceptor_t = _cef_v8interceptor_t;
-
-///
-// Structure representing a V8 exception. The functions of this structure may be
-// called on any render process thread.
-///
-struct _cef_v8exception_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the exception message.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_v8exception_t* self) nothrow get_message;
-
-    ///
-    // Returns the line of source code that the exception occurred within.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_v8exception_t* self) nothrow get_source_line;
-
-    ///
-    // Returns the resource name for the script from where the function causing
-    // the error originates.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_v8exception_t* self) nothrow get_script_resource_name;
-
-    ///
-    // Returns the 1-based number of the line where the error occurred or 0 if the
-    // line number is unknown.
-    ///
-    int function (_cef_v8exception_t* self) nothrow get_line_number;
-
-    ///
-    // Returns the index within the script of the first character where the error
-    // occurred.
-    ///
-    int function (_cef_v8exception_t* self) nothrow get_start_position;
-
-    ///
-    // Returns the index within the script of the last character where the error
-    // occurred.
-    ///
-    int function (_cef_v8exception_t* self) nothrow get_end_position;
-
-    ///
-    // Returns the index within the line of the first character where the error
-    // occurred.
-    ///
-    int function (_cef_v8exception_t* self) nothrow get_start_column;
-
-    ///
-    // Returns the index within the line of the last character where the error
-    // occurred.
-    ///
-    int function (_cef_v8exception_t* self) nothrow get_end_column;
-}
-
-alias cef_v8exception_t = _cef_v8exception_t;
-
-///
-// Callback structure that is passed to cef_v8value_t::CreateArrayBuffer.
-///
-struct _cef_v8array_buffer_release_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Called to release |buffer| when the ArrayBuffer JS object is garbage
-    // collected. |buffer| is the value that was passed to CreateArrayBuffer along
-    // with this object.
-    ///
-    void function (
-        _cef_v8array_buffer_release_callback_t* self,
-        void* buffer) nothrow release_buffer;
-}
-
-alias cef_v8array_buffer_release_callback_t = _cef_v8array_buffer_release_callback_t;
-
-///
-// Structure representing a V8 value handle. V8 handles can only be accessed
-// from the thread on which they are created. Valid threads for creating a V8
-// handle include the render process main thread (TID_RENDERER) and WebWorker
-// threads. A task runner for posting tasks on the associated thread can be
-// retrieved via the cef_v8context_t::get_task_runner() function.
-///
-struct _cef_v8value_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if the underlying handle is valid and it can be accessed
-    // on the current thread. Do not call any other functions if this function
-    // returns false (0).
-    ///
-    int function (_cef_v8value_t* self) nothrow is_valid;
-
-    ///
-    // True if the value type is undefined.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_undefined;
-
-    ///
-    // True if the value type is null.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_null;
-
-    ///
-    // True if the value type is bool.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_bool;
-
-    ///
-    // True if the value type is int.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_int;
-
-    ///
-    // True if the value type is unsigned int.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_uint;
-
-    ///
-    // True if the value type is double.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_double;
-
-    ///
-    // True if the value type is Date.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_date;
-
-    ///
-    // True if the value type is string.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_string;
-
-    ///
-    // True if the value type is object.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_object;
-
-    ///
-    // True if the value type is array.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_array;
-
-    ///
-    // True if the value type is an ArrayBuffer.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_array_buffer;
-
-    ///
-    // True if the value type is function.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_function;
-
-    ///
-    // Returns true (1) if this object is pointing to the same handle as |that|
-    // object.
-    ///
-    int function (_cef_v8value_t* self, _cef_v8value_t* that) nothrow is_same;
-
-    ///
-    // Return a bool value.
-    ///
-    int function (_cef_v8value_t* self) nothrow get_bool_value;
-
-    ///
-    // Return an int value.
-    ///
-    int32 function (_cef_v8value_t* self) nothrow get_int_value;
-
-    ///
-    // Return an unsigned int value.
-    ///
-    uint32 function (_cef_v8value_t* self) nothrow get_uint_value;
-
-    ///
-    // Return a double value.
-    ///
-    double function (_cef_v8value_t* self) nothrow get_double_value;
-
-    ///
-    // Return a Date value.
-    ///
-    cef_time_t function (_cef_v8value_t* self) nothrow get_date_value;
-
-    ///
-    // Return a string value.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_v8value_t* self) nothrow get_string_value;
-
-    // OBJECT METHODS - These functions are only available on objects. Arrays and
-    // functions are also objects. String- and integer-based keys can be used
-    // interchangably with the framework converting between them as necessary.
-
-    ///
-    // Returns true (1) if this is a user created object.
-    ///
-    int function (_cef_v8value_t* self) nothrow is_user_created;
-
-    ///
-    // Returns true (1) if the last function call resulted in an exception. This
-    // attribute exists only in the scope of the current CEF value object.
-    ///
-    int function (_cef_v8value_t* self) nothrow has_exception;
-
-    ///
-    // Returns the exception resulting from the last function call. This attribute
-    // exists only in the scope of the current CEF value object.
-    ///
-    _cef_v8exception_t* function (_cef_v8value_t* self) nothrow get_exception;
-
-    ///
-    // Clears the last exception and returns true (1) on success.
-    ///
-    int function (_cef_v8value_t* self) nothrow clear_exception;
-
-    ///
-    // Returns true (1) if this object will re-throw future exceptions. This
-    // attribute exists only in the scope of the current CEF value object.
-    ///
-    int function (_cef_v8value_t* self) nothrow will_rethrow_exceptions;
-
-    ///
-    // Set whether this object will re-throw future exceptions. By default
-    // exceptions are not re-thrown. If a exception is re-thrown the current
-    // context should not be accessed again until after the exception has been
-    // caught and not re-thrown. Returns true (1) on success. This attribute
-    // exists only in the scope of the current CEF value object.
-    ///
-    int function (_cef_v8value_t* self, int rethrow) nothrow set_rethrow_exceptions;
-
-    ///
-    // Returns true (1) if the object has a value with the specified identifier.
-    ///
-    int function (
-        _cef_v8value_t* self,
-        const(cef_string_t)* key) nothrow has_value_bykey;
-
-    ///
-    // Returns true (1) if the object has a value with the specified identifier.
-    ///
-    int function (_cef_v8value_t* self, int index) nothrow has_value_byindex;
-
-    ///
-    // Deletes the value with the specified identifier and returns true (1) on
-    // success. Returns false (0) if this function is called incorrectly or an
-    // exception is thrown. For read-only and don't-delete values this function
-    // will return true (1) even though deletion failed.
-    ///
-    int function (
-        _cef_v8value_t* self,
-        const(cef_string_t)* key) nothrow delete_value_bykey;
-
-    ///
-    // Deletes the value with the specified identifier and returns true (1) on
-    // success. Returns false (0) if this function is called incorrectly, deletion
-    // fails or an exception is thrown. For read-only and don't-delete values this
-    // function will return true (1) even though deletion failed.
-    ///
-    int function (_cef_v8value_t* self, int index) nothrow delete_value_byindex;
-
-    ///
-    // Returns the value with the specified identifier on success. Returns NULL if
-    // this function is called incorrectly or an exception is thrown.
-    ///
-    _cef_v8value_t* function (
-        _cef_v8value_t* self,
-        const(cef_string_t)* key) nothrow get_value_bykey;
-
-    ///
-    // Returns the value with the specified identifier on success. Returns NULL if
-    // this function is called incorrectly or an exception is thrown.
-    ///
-    _cef_v8value_t* function (
-        _cef_v8value_t* self,
-        int index) nothrow get_value_byindex;
-
-    ///
-    // Associates a value with the specified identifier and returns true (1) on
-    // success. Returns false (0) if this function is called incorrectly or an
-    // exception is thrown. For read-only values this function will return true
-    // (1) even though assignment failed.
-    ///
-    int function (
-        _cef_v8value_t* self,
-        const(cef_string_t)* key,
-        _cef_v8value_t* value,
-        cef_v8_propertyattribute_t attribute) nothrow set_value_bykey;
-
-    ///
-    // Associates a value with the specified identifier and returns true (1) on
-    // success. Returns false (0) if this function is called incorrectly or an
-    // exception is thrown. For read-only values this function will return true
-    // (1) even though assignment failed.
-    ///
-    int function (
-        _cef_v8value_t* self,
-        int index,
-        _cef_v8value_t* value) nothrow set_value_byindex;
-
-    ///
-    // Registers an identifier and returns true (1) on success. Access to the
-    // identifier will be forwarded to the cef_v8accessor_t instance passed to
-    // cef_v8value_t::cef_v8value_create_object(). Returns false (0) if this
-    // function is called incorrectly or an exception is thrown. For read-only
-    // values this function will return true (1) even though assignment failed.
-    ///
-    int function (
-        _cef_v8value_t* self,
-        const(cef_string_t)* key,
-        cef_v8_accesscontrol_t settings,
-        cef_v8_propertyattribute_t attribute) nothrow set_value_byaccessor;
-
-    ///
-    // Read the keys for the object's values into the specified vector. Integer-
-    // based keys will also be returned as strings.
-    ///
-    int function (_cef_v8value_t* self, cef_string_list_t keys) nothrow get_keys;
-
-    ///
-    // Sets the user data for this object and returns true (1) on success. Returns
-    // false (0) if this function is called incorrectly. This function can only be
-    // called on user created objects.
-    ///
-    int function (
-        _cef_v8value_t* self,
-        _cef_base_ref_counted_t* user_data) nothrow set_user_data;
-
-    ///
-    // Returns the user data, if any, assigned to this object.
-    ///
-    _cef_base_ref_counted_t* function (_cef_v8value_t* self) nothrow get_user_data;
-
-    ///
-    // Returns the amount of externally allocated memory registered for the
-    // object.
-    ///
-    int function (_cef_v8value_t* self) nothrow get_externally_allocated_memory;
-
-    ///
-    // Adjusts the amount of registered external memory for the object. Used to
-    // give V8 an indication of the amount of externally allocated memory that is
-    // kept alive by JavaScript objects. V8 uses this information to decide when
-    // to perform global garbage collection. Each cef_v8value_t tracks the amount
-    // of external memory associated with it and automatically decreases the
-    // global total by the appropriate amount on its destruction.
-    // |change_in_bytes| specifies the number of bytes to adjust by. This function
-    // returns the number of bytes associated with the object after the
-    // adjustment. This function can only be called on user created objects.
-    ///
-    int function (
-        _cef_v8value_t* self,
-        int change_in_bytes) nothrow adjust_externally_allocated_memory;
-
-    // ARRAY METHODS - These functions are only available on arrays.
-
-    ///
-    // Returns the number of elements in the array.
-    ///
-    int function (_cef_v8value_t* self) nothrow get_array_length;
-
-    // ARRAY BUFFER METHODS - These functions are only available on ArrayBuffers.
-
-    ///
-    // Returns the ReleaseCallback object associated with the ArrayBuffer or NULL
-    // if the ArrayBuffer was not created with CreateArrayBuffer.
-    ///
-    _cef_v8array_buffer_release_callback_t* function (
-        _cef_v8value_t* self) nothrow get_array_buffer_release_callback;
-
-    ///
-    // Prevent the ArrayBuffer from using it's memory block by setting the length
-    // to zero. This operation cannot be undone. If the ArrayBuffer was created
-    // with CreateArrayBuffer then
-    // cef_v8array_buffer_release_callback_t::ReleaseBuffer will be called to
-    // release the underlying buffer.
-    ///
-    int function (_cef_v8value_t* self) nothrow neuter_array_buffer;
-
-    // FUNCTION METHODS - These functions are only available on functions.
-
-    ///
-    // Returns the function name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_v8value_t* self) nothrow get_function_name;
-
-    ///
-    // Returns the function handler or NULL if not a CEF-created function.
-    ///
-    _cef_v8handler_t* function (_cef_v8value_t* self) nothrow get_function_handler;
-
-    ///
-    // Execute the function using the current V8 context. This function should
-    // only be called from within the scope of a cef_v8handler_t or
-    // cef_v8accessor_t callback, or in combination with calling enter() and
-    // exit() on a stored cef_v8context_t reference. |object| is the receiver
-    // ('this' object) of the function. If |object| is NULL the current context's
-    // global object will be used. |arguments| is the list of arguments that will
-    // be passed to the function. Returns the function return value on success.
-    // Returns NULL if this function is called incorrectly or an exception is
-    // thrown.
-    ///
-    _cef_v8value_t* function (
-        _cef_v8value_t* self,
-        _cef_v8value_t* object,
-        size_t argumentsCount,
-        _cef_v8value_t** arguments) nothrow execute_function;
-
-    ///
-    // Execute the function using the specified V8 context. |object| is the
-    // receiver ('this' object) of the function. If |object| is NULL the specified
-    // context's global object will be used. |arguments| is the list of arguments
-    // that will be passed to the function. Returns the function return value on
-    // success. Returns NULL if this function is called incorrectly or an
-    // exception is thrown.
-    ///
-    _cef_v8value_t* function (
-        _cef_v8value_t* self,
-        _cef_v8context_t* context,
-        _cef_v8value_t* object,
-        size_t argumentsCount,
-        _cef_v8value_t** arguments) nothrow execute_function_with_context;
-}
-
-alias cef_v8value_t = _cef_v8value_t;
-
-///
-// Create a new cef_v8value_t object of type undefined.
-///
-cef_v8value_t* cef_v8value_create_undefined ();
-
-///
-// Create a new cef_v8value_t object of type null.
-///
-cef_v8value_t* cef_v8value_create_null ();
-
-///
-// Create a new cef_v8value_t object of type bool.
-///
-cef_v8value_t* cef_v8value_create_bool (int value);
-
-///
-// Create a new cef_v8value_t object of type int.
-///
-cef_v8value_t* cef_v8value_create_int (int32 value);
-
-///
-// Create a new cef_v8value_t object of type unsigned int.
-///
-cef_v8value_t* cef_v8value_create_uint (uint32 value);
-
-///
-// Create a new cef_v8value_t object of type double.
-///
-cef_v8value_t* cef_v8value_create_double (double value);
-
-///
-// Create a new cef_v8value_t object of type Date. This function should only be
-// called from within the scope of a cef_render_process_handler_t,
-// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling
-// enter() and exit() on a stored cef_v8context_t reference.
-///
-cef_v8value_t* cef_v8value_create_date (const(cef_time_t)* date);
-
-///
-// Create a new cef_v8value_t object of type string.
-///
-cef_v8value_t* cef_v8value_create_string (const(cef_string_t)* value);
-
-///
-// Create a new cef_v8value_t object of type object with optional accessor
-// and/or interceptor. This function should only be called from within the scope
-// of a cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t
-// callback, or in combination with calling enter() and exit() on a stored
-// cef_v8context_t reference.
-///
-cef_v8value_t* cef_v8value_create_object (
-    cef_v8accessor_t* accessor,
-    cef_v8interceptor_t* interceptor);
-
-///
-// Create a new cef_v8value_t object of type array with the specified |length|.
-// If |length| is negative the returned array will have length 0. This function
-// should only be called from within the scope of a
-// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback,
-// or in combination with calling enter() and exit() on a stored cef_v8context_t
-// reference.
-///
-cef_v8value_t* cef_v8value_create_array (int length);
-
-///
-// Create a new cef_v8value_t object of type ArrayBuffer which wraps the
-// provided |buffer| of size |length| bytes. The ArrayBuffer is externalized,
-// meaning that it does not own |buffer|. The caller is responsible for freeing
-// |buffer| when requested via a call to cef_v8array_buffer_release_callback_t::
-// ReleaseBuffer. This function should only be called from within the scope of a
-// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback,
-// or in combination with calling enter() and exit() on a stored cef_v8context_t
-// reference.
-///
-cef_v8value_t* cef_v8value_create_array_buffer (
-    void* buffer,
-    size_t length,
-    cef_v8array_buffer_release_callback_t* release_callback);
-
-///
-// Create a new cef_v8value_t object of type function. This function should only
-// be called from within the scope of a cef_render_process_handler_t,
-// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling
-// enter() and exit() on a stored cef_v8context_t reference.
-///
-cef_v8value_t* cef_v8value_create_function (
-    const(cef_string_t)* name,
-    cef_v8handler_t* handler) nothrow;
-
-///
-// Structure representing a V8 stack trace handle. V8 handles can only be
-// accessed from the thread on which they are created. Valid threads for
-// creating a V8 handle include the render process main thread (TID_RENDERER)
-// and WebWorker threads. A task runner for posting tasks on the associated
-// thread can be retrieved via the cef_v8context_t::get_task_runner() function.
-///
-struct _cef_v8stack_trace_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if the underlying handle is valid and it can be accessed
-    // on the current thread. Do not call any other functions if this function
-    // returns false (0).
-    ///
-    int function (_cef_v8stack_trace_t* self) nothrow is_valid;
-
-    ///
-    // Returns the number of stack frames.
-    ///
-    int function (_cef_v8stack_trace_t* self) nothrow get_frame_count;
-
-    ///
-    // Returns the stack frame at the specified 0-based index.
-    ///
-    _cef_v8stack_frame_t* function (
-        _cef_v8stack_trace_t* self,
-        int index) nothrow get_frame;
-}
-
-alias cef_v8stack_trace_t = _cef_v8stack_trace_t;
-
-///
-// Returns the stack trace for the currently active context. |frame_limit| is
-// the maximum number of frames that will be captured.
-///
-cef_v8stack_trace_t* cef_v8stack_trace_get_current (int frame_limit);
-
-///
-// Structure representing a V8 stack frame handle. V8 handles can only be
-// accessed from the thread on which they are created. Valid threads for
-// creating a V8 handle include the render process main thread (TID_RENDERER)
-// and WebWorker threads. A task runner for posting tasks on the associated
-// thread can be retrieved via the cef_v8context_t::get_task_runner() function.
-///
-struct _cef_v8stack_frame_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if the underlying handle is valid and it can be accessed
-    // on the current thread. Do not call any other functions if this function
-    // returns false (0).
-    ///
-    int function (_cef_v8stack_frame_t* self) nothrow is_valid;
-
-    ///
-    // Returns the name of the resource script that contains the function.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_v8stack_frame_t* self) nothrow get_script_name;
-
-    ///
-    // Returns the name of the resource script that contains the function or the
-    // sourceURL value if the script name is undefined and its source ends with a
-    // "//@ sourceURL=..." string.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_v8stack_frame_t* self) nothrow get_script_name_or_source_url;
-
-    ///
-    // Returns the name of the function.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_v8stack_frame_t* self) nothrow get_function_name;
-
-    ///
-    // Returns the 1-based line number for the function call or 0 if unknown.
-    ///
-    int function (_cef_v8stack_frame_t* self) nothrow get_line_number;
-
-    ///
-    // Returns the 1-based column offset on the line for the function call or 0 if
-    // unknown.
-    ///
-    int function (_cef_v8stack_frame_t* self) nothrow get_column;
-
-    ///
-    // Returns true (1) if the function was compiled using eval().
-    ///
-    int function (_cef_v8stack_frame_t* self) nothrow is_eval;
-
-    ///
-    // Returns true (1) if the function was called as a constructor via "new".
-    ///
-    int function (_cef_v8stack_frame_t* self) nothrow is_constructor;
-}
-
-alias cef_v8stack_frame_t = _cef_v8stack_frame_t;
-
-///
-// Register a new V8 extension with the specified JavaScript extension code and
-// handler. Functions implemented by the handler are prototyped using the
-// keyword 'native'. The calling of a native function is restricted to the scope
-// in which the prototype of the native function is defined. This function may
-// only be called on the render process main thread.
-//
-// Example JavaScript extension code: <pre>
-//   // create the 'example' global object if it doesn't already exist.
-//   if (!example)
-//     example = {};
-//   // create the 'example.test' global object if it doesn't already exist.
-//   if (!example.test)
-//     example.test = {};
-//   (function() {
-//     // Define the function 'example.test.myfunction'.
-//     example.test.myfunction = function() {
-//       // Call CefV8Handler::Execute() with the function name 'MyFunction'
-//       // and no arguments.
-//       native function MyFunction();
-//       return MyFunction();
-//     };
-//     // Define the getter function for parameter 'example.test.myparam'.
-//     example.test.__defineGetter__('myparam', function() {
-//       // Call CefV8Handler::Execute() with the function name 'GetMyParam'
-//       // and no arguments.
-//       native function GetMyParam();
-//       return GetMyParam();
-//     });
-//     // Define the setter function for parameter 'example.test.myparam'.
-//     example.test.__defineSetter__('myparam', function(b) {
-//       // Call CefV8Handler::Execute() with the function name 'SetMyParam'
-//       // and a single argument.
-//       native function SetMyParam();
-//       if(b) SetMyParam(b);
-//     });
-//
-//     // Extension definitions can also contain normal JavaScript variables
-//     // and functions.
-//     var myint = 0;
-//     example.test.increment = function() {
-//       myint += 1;
-//       return myint;
-//     };
-//   })();
-// </pre> Example usage in the page: <pre>
-//   // Call the function.
-//   example.test.myfunction();
-//   // Set the parameter.
-//   example.test.myparam = value;
-//   // Get the parameter.
-//   value = example.test.myparam;
-//   // Call another function.
-//   example.test.increment();
-// </pre>
-///
-int cef_register_extension (
-    const(cef_string_t)* extension_name,
-    const(cef_string_t)* javascript_code,
-    cef_v8handler_t* handler);
-
-// CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=22f935968cd7f2549def42f5d84694311bde125e$
-//
-
-extern (C):
-
-///
-// Structure that wraps other data value types. Complex types (binary,
-// dictionary and list) will be referenced but not owned by this object. Can be
-// used on any process and thread.
-///
-struct _cef_value_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if the underlying data is valid. This will always be true
-    // (1) for simple types. For complex types (binary, dictionary and list) the
-    // underlying data may become invalid if owned by another object (e.g. list or
-    // dictionary) and that other object is then modified or destroyed. This value
-    // object can be re-used by calling Set*() even if the underlying data is
-    // invalid.
-    ///
-    int function (_cef_value_t* self) nothrow is_valid;
-
-    ///
-    // Returns true (1) if the underlying data is owned by another object.
-    ///
-    int function (_cef_value_t* self) nothrow is_owned;
-
-    ///
-    // Returns true (1) if the underlying data is read-only. Some APIs may expose
-    // read-only objects.
-    ///
-    int function (_cef_value_t* self) nothrow is_read_only;
-
-    ///
-    // Returns true (1) if this object and |that| object have the same underlying
-    // data. If true (1) modifications to this object will also affect |that|
-    // object and vice-versa.
-    ///
-    int function (_cef_value_t* self, _cef_value_t* that) nothrow is_same;
-
-    ///
-    // Returns true (1) if this object and |that| object have an equivalent
-    // underlying value but are not necessarily the same object.
-    ///
-    int function (_cef_value_t* self, _cef_value_t* that) nothrow is_equal;
-
-    ///
-    // Returns a copy of this object. The underlying data will also be copied.
-    ///
-    _cef_value_t* function (_cef_value_t* self) nothrow copy;
-
-    ///
-    // Returns the underlying value type.
-    ///
-    cef_value_type_t function (_cef_value_t* self) nothrow get_type;
-
-    ///
-    // Returns the underlying value as type bool.
-    ///
-    int function (_cef_value_t* self) nothrow get_bool;
-
-    ///
-    // Returns the underlying value as type int.
-    ///
-    int function (_cef_value_t* self) nothrow get_int;
-
-    ///
-    // Returns the underlying value as type double.
-    ///
-    double function (_cef_value_t* self) nothrow get_double;
-
-    ///
-    // Returns the underlying value as type string.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_value_t* self) nothrow get_string;
-
-    ///
-    // Returns the underlying value as type binary. The returned reference may
-    // become invalid if the value is owned by another object or if ownership is
-    // transferred to another object in the future. To maintain a reference to the
-    // value after assigning ownership to a dictionary or list pass this object to
-    // the set_value() function instead of passing the returned reference to
-    // set_binary().
-    ///
-    _cef_binary_value_t* function (_cef_value_t* self) nothrow get_binary;
-
-    ///
-    // Returns the underlying value as type dictionary. The returned reference may
-    // become invalid if the value is owned by another object or if ownership is
-    // transferred to another object in the future. To maintain a reference to the
-    // value after assigning ownership to a dictionary or list pass this object to
-    // the set_value() function instead of passing the returned reference to
-    // set_dictionary().
-    ///
-    _cef_dictionary_value_t* function (_cef_value_t* self) nothrow get_dictionary;
-
-    ///
-    // Returns the underlying value as type list. The returned reference may
-    // become invalid if the value is owned by another object or if ownership is
-    // transferred to another object in the future. To maintain a reference to the
-    // value after assigning ownership to a dictionary or list pass this object to
-    // the set_value() function instead of passing the returned reference to
-    // set_list().
-    ///
-    _cef_list_value_t* function (_cef_value_t* self) nothrow get_list;
-
-    ///
-    // Sets the underlying value as type null. Returns true (1) if the value was
-    // set successfully.
-    ///
-    int function (_cef_value_t* self) nothrow set_null;
-
-    ///
-    // Sets the underlying value as type bool. Returns true (1) if the value was
-    // set successfully.
-    ///
-    int function (_cef_value_t* self, int value) nothrow set_bool;
-
-    ///
-    // Sets the underlying value as type int. Returns true (1) if the value was
-    // set successfully.
-    ///
-    int function (_cef_value_t* self, int value) nothrow set_int;
-
-    ///
-    // Sets the underlying value as type double. Returns true (1) if the value was
-    // set successfully.
-    ///
-    int function (_cef_value_t* self, double value) nothrow set_double;
-
-    ///
-    // Sets the underlying value as type string. Returns true (1) if the value was
-    // set successfully.
-    ///
-    int function (_cef_value_t* self, const(cef_string_t)* value) nothrow set_string;
-
-    ///
-    // Sets the underlying value as type binary. Returns true (1) if the value was
-    // set successfully. This object keeps a reference to |value| and ownership of
-    // the underlying data remains unchanged.
-    ///
-    int function (_cef_value_t* self, _cef_binary_value_t* value) nothrow set_binary;
-
-    ///
-    // Sets the underlying value as type dict. Returns true (1) if the value was
-    // set successfully. This object keeps a reference to |value| and ownership of
-    // the underlying data remains unchanged.
-    ///
-    int function (
-        _cef_value_t* self,
-        _cef_dictionary_value_t* value) nothrow set_dictionary;
-
-    ///
-    // Sets the underlying value as type list. Returns true (1) if the value was
-    // set successfully. This object keeps a reference to |value| and ownership of
-    // the underlying data remains unchanged.
-    ///
-    int function (_cef_value_t* self, _cef_list_value_t* value) nothrow set_list;
-}
-
-alias cef_value_t = _cef_value_t;
-
-///
-// Creates a new object.
-///
-cef_value_t* cef_value_create ();
-
-///
-// Structure representing a binary value. Can be used on any process and thread.
-///
-struct _cef_binary_value_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is valid. This object may become invalid if
-    // the underlying data is owned by another object (e.g. list or dictionary)
-    // and that other object is then modified or destroyed. Do not call any other
-    // functions if this function returns false (0).
-    ///
-    int function (_cef_binary_value_t* self) nothrow is_valid;
-
-    ///
-    // Returns true (1) if this object is currently owned by another object.
-    ///
-    int function (_cef_binary_value_t* self) nothrow is_owned;
-
-    ///
-    // Returns true (1) if this object and |that| object have the same underlying
-    // data.
-    ///
-    int function (
-        _cef_binary_value_t* self,
-        _cef_binary_value_t* that) nothrow is_same;
-
-    ///
-    // Returns true (1) if this object and |that| object have an equivalent
-    // underlying value but are not necessarily the same object.
-    ///
-    int function (
-        _cef_binary_value_t* self,
-        _cef_binary_value_t* that) nothrow is_equal;
-
-    ///
-    // Returns a copy of this object. The data in this object will also be copied.
-    ///
-    _cef_binary_value_t* function (_cef_binary_value_t* self) nothrow copy;
-
-    ///
-    // Returns the data size.
-    ///
-    size_t function (_cef_binary_value_t* self) nothrow get_size;
-
-    ///
-    // Read up to |buffer_size| number of bytes into |buffer|. Reading begins at
-    // the specified byte |data_offset|. Returns the number of bytes read.
-    ///
-    size_t function (
-        _cef_binary_value_t* self,
-        void* buffer,
-        size_t buffer_size,
-        size_t data_offset) nothrow get_data;
-}
-
-alias cef_binary_value_t = _cef_binary_value_t;
-
-///
-// Creates a new object that is not owned by any other object. The specified
-// |data| will be copied.
-///
-cef_binary_value_t* cef_binary_value_create (
-    const(void)* data,
-    size_t data_size);
-
-///
-// Structure representing a dictionary value. Can be used on any process and
-// thread.
-///
-struct _cef_dictionary_value_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is valid. This object may become invalid if
-    // the underlying data is owned by another object (e.g. list or dictionary)
-    // and that other object is then modified or destroyed. Do not call any other
-    // functions if this function returns false (0).
-    ///
-    int function (_cef_dictionary_value_t* self) nothrow is_valid;
-
-    ///
-    // Returns true (1) if this object is currently owned by another object.
-    ///
-    int function (_cef_dictionary_value_t* self) nothrow is_owned;
-
-    ///
-    // Returns true (1) if the values of this object are read-only. Some APIs may
-    // expose read-only objects.
-    ///
-    int function (_cef_dictionary_value_t* self) nothrow is_read_only;
-
-    ///
-    // Returns true (1) if this object and |that| object have the same underlying
-    // data. If true (1) modifications to this object will also affect |that|
-    // object and vice-versa.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        _cef_dictionary_value_t* that) nothrow is_same;
-
-    ///
-    // Returns true (1) if this object and |that| object have an equivalent
-    // underlying value but are not necessarily the same object.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        _cef_dictionary_value_t* that) nothrow is_equal;
-
-    ///
-    // Returns a writable copy of this object. If |exclude_NULL_children| is true
-    // (1) any NULL dictionaries or lists will be excluded from the copy.
-    ///
-    _cef_dictionary_value_t* function (
-        _cef_dictionary_value_t* self,
-        int exclude_empty_children) nothrow copy;
-
-    ///
-    // Returns the number of values.
-    ///
-    size_t function (_cef_dictionary_value_t* self) nothrow get_size;
-
-    ///
-    // Removes all values. Returns true (1) on success.
-    ///
-    int function (_cef_dictionary_value_t* self) nothrow clear;
-
-    ///
-    // Returns true (1) if the current dictionary has a value for the given key.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow has_key;
-
-    ///
-    // Reads all keys for this dictionary into the specified vector.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        cef_string_list_t keys) nothrow get_keys;
-
-    ///
-    // Removes the value at the specified key. Returns true (1) is the value was
-    // removed successfully.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow remove;
-
-    ///
-    // Returns the value type for the specified key.
-    ///
-    cef_value_type_t function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow get_type;
-
-    ///
-    // Returns the value at the specified key. For simple types the returned value
-    // will copy existing data and modifications to the value will not modify this
-    // object. For complex types (binary, dictionary and list) the returned value
-    // will reference existing data and modifications to the value will modify
-    // this object.
-    ///
-    _cef_value_t* function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow get_value;
-
-    ///
-    // Returns the value at the specified key as type bool.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow get_bool;
-
-    ///
-    // Returns the value at the specified key as type int.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow get_int;
-
-    ///
-    // Returns the value at the specified key as type double.
-    ///
-    double function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow get_double;
-
-    ///
-    // Returns the value at the specified key as type string.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow get_string;
-
-    ///
-    // Returns the value at the specified key as type binary. The returned value
-    // will reference existing data.
-    ///
-    _cef_binary_value_t* function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow get_binary;
-
-    ///
-    // Returns the value at the specified key as type dictionary. The returned
-    // value will reference existing data and modifications to the value will
-    // modify this object.
-    ///
-    _cef_dictionary_value_t* function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow get_dictionary;
-
-    ///
-    // Returns the value at the specified key as type list. The returned value
-    // will reference existing data and modifications to the value will modify
-    // this object.
-    ///
-    _cef_list_value_t* function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow get_list;
-
-    ///
-    // Sets the value at the specified key. Returns true (1) if the value was set
-    // successfully. If |value| represents simple data then the underlying data
-    // will be copied and modifications to |value| will not modify this object. If
-    // |value| represents complex data (binary, dictionary or list) then the
-    // underlying data will be referenced and modifications to |value| will modify
-    // this object.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key,
-        _cef_value_t* value) nothrow set_value;
-
-    ///
-    // Sets the value at the specified key as type null. Returns true (1) if the
-    // value was set successfully.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key) nothrow set_null;
-
-    ///
-    // Sets the value at the specified key as type bool. Returns true (1) if the
-    // value was set successfully.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key,
-        int value) nothrow set_bool;
-
-    ///
-    // Sets the value at the specified key as type int. Returns true (1) if the
-    // value was set successfully.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key,
-        int value) nothrow set_int;
-
-    ///
-    // Sets the value at the specified key as type double. Returns true (1) if the
-    // value was set successfully.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key,
-        double value) nothrow set_double;
-
-    ///
-    // Sets the value at the specified key as type string. Returns true (1) if the
-    // value was set successfully.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key,
-        const(cef_string_t)* value) nothrow set_string;
-
-    ///
-    // Sets the value at the specified key as type binary. Returns true (1) if the
-    // value was set successfully. If |value| is currently owned by another object
-    // then the value will be copied and the |value| reference will not change.
-    // Otherwise, ownership will be transferred to this object and the |value|
-    // reference will be invalidated.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key,
-        _cef_binary_value_t* value) nothrow set_binary;
-
-    ///
-    // Sets the value at the specified key as type dict. Returns true (1) if the
-    // value was set successfully. If |value| is currently owned by another object
-    // then the value will be copied and the |value| reference will not change.
-    // Otherwise, ownership will be transferred to this object and the |value|
-    // reference will be invalidated.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key,
-        _cef_dictionary_value_t* value) nothrow set_dictionary;
-
-    ///
-    // Sets the value at the specified key as type list. Returns true (1) if the
-    // value was set successfully. If |value| is currently owned by another object
-    // then the value will be copied and the |value| reference will not change.
-    // Otherwise, ownership will be transferred to this object and the |value|
-    // reference will be invalidated.
-    ///
-    int function (
-        _cef_dictionary_value_t* self,
-        const(cef_string_t)* key,
-        _cef_list_value_t* value) nothrow set_list;
-}
-
-alias cef_dictionary_value_t = _cef_dictionary_value_t;
-
-///
-// Creates a new object that is not owned by any other object.
-///
-cef_dictionary_value_t* cef_dictionary_value_create ();
-
-///
-// Structure representing a list value. Can be used on any process and thread.
-///
-struct _cef_list_value_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns true (1) if this object is valid. This object may become invalid if
-    // the underlying data is owned by another object (e.g. list or dictionary)
-    // and that other object is then modified or destroyed. Do not call any other
-    // functions if this function returns false (0).
-    ///
-    int function (_cef_list_value_t* self) nothrow is_valid;
-
-    ///
-    // Returns true (1) if this object is currently owned by another object.
-    ///
-    int function (_cef_list_value_t* self) nothrow is_owned;
-
-    ///
-    // Returns true (1) if the values of this object are read-only. Some APIs may
-    // expose read-only objects.
-    ///
-    int function (_cef_list_value_t* self) nothrow is_read_only;
-
-    ///
-    // Returns true (1) if this object and |that| object have the same underlying
-    // data. If true (1) modifications to this object will also affect |that|
-    // object and vice-versa.
-    ///
-    int function (_cef_list_value_t* self, _cef_list_value_t* that) nothrow is_same;
-
-    ///
-    // Returns true (1) if this object and |that| object have an equivalent
-    // underlying value but are not necessarily the same object.
-    ///
-    int function (_cef_list_value_t* self, _cef_list_value_t* that) nothrow is_equal;
-
-    ///
-    // Returns a writable copy of this object.
-    ///
-    _cef_list_value_t* function (_cef_list_value_t* self) nothrow copy;
-
-    ///
-    // Sets the number of values. If the number of values is expanded all new
-    // value slots will default to type null. Returns true (1) on success.
-    ///
-    int function (_cef_list_value_t* self, size_t size) nothrow set_size;
-
-    ///
-    // Returns the number of values.
-    ///
-    size_t function (_cef_list_value_t* self) nothrow get_size;
-
-    ///
-    // Removes all values. Returns true (1) on success.
-    ///
-    int function (_cef_list_value_t* self) nothrow clear;
-
-    ///
-    // Removes the value at the specified index.
-    ///
-    int function (_cef_list_value_t* self, size_t index) nothrow remove;
-
-    ///
-    // Returns the value type at the specified index.
-    ///
-    cef_value_type_t function (_cef_list_value_t* self, size_t index) nothrow get_type;
-
-    ///
-    // Returns the value at the specified index. For simple types the returned
-    // value will copy existing data and modifications to the value will not
-    // modify this object. For complex types (binary, dictionary and list) the
-    // returned value will reference existing data and modifications to the value
-    // will modify this object.
-    ///
-    _cef_value_t* function (_cef_list_value_t* self, size_t index) nothrow get_value;
-
-    ///
-    // Returns the value at the specified index as type bool.
-    ///
-    int function (_cef_list_value_t* self, size_t index) nothrow get_bool;
-
-    ///
-    // Returns the value at the specified index as type int.
-    ///
-    int function (_cef_list_value_t* self, size_t index) nothrow get_int;
-
-    ///
-    // Returns the value at the specified index as type double.
-    ///
-    double function (_cef_list_value_t* self, size_t index) nothrow get_double;
-
-    ///
-    // Returns the value at the specified index as type string.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_list_value_t* self,
-        size_t index) nothrow get_string;
-
-    ///
-    // Returns the value at the specified index as type binary. The returned value
-    // will reference existing data.
-    ///
-    _cef_binary_value_t* function (
-        _cef_list_value_t* self,
-        size_t index) nothrow get_binary;
-
-    ///
-    // Returns the value at the specified index as type dictionary. The returned
-    // value will reference existing data and modifications to the value will
-    // modify this object.
-    ///
-    _cef_dictionary_value_t* function (
-        _cef_list_value_t* self,
-        size_t index) nothrow get_dictionary;
-
-    ///
-    // Returns the value at the specified index as type list. The returned value
-    // will reference existing data and modifications to the value will modify
-    // this object.
-    ///
-    _cef_list_value_t* function (
-        _cef_list_value_t* self,
-        size_t index) nothrow get_list;
-
-    ///
-    // Sets the value at the specified index. Returns true (1) if the value was
-    // set successfully. If |value| represents simple data then the underlying
-    // data will be copied and modifications to |value| will not modify this
-    // object. If |value| represents complex data (binary, dictionary or list)
-    // then the underlying data will be referenced and modifications to |value|
-    // will modify this object.
-    ///
-    int function (
-        _cef_list_value_t* self,
-        size_t index,
-        _cef_value_t* value) nothrow set_value;
-
-    ///
-    // Sets the value at the specified index as type null. Returns true (1) if the
-    // value was set successfully.
-    ///
-    int function (_cef_list_value_t* self, size_t index) nothrow set_null;
-
-    ///
-    // Sets the value at the specified index as type bool. Returns true (1) if the
-    // value was set successfully.
-    ///
-    int function (_cef_list_value_t* self, size_t index, int value) nothrow set_bool;
-
-    ///
-    // Sets the value at the specified index as type int. Returns true (1) if the
-    // value was set successfully.
-    ///
-    int function (_cef_list_value_t* self, size_t index, int value) nothrow set_int;
-
-    ///
-    // Sets the value at the specified index as type double. Returns true (1) if
-    // the value was set successfully.
-    ///
-    int function (
-        _cef_list_value_t* self,
-        size_t index,
-        double value) nothrow set_double;
-
-    ///
-    // Sets the value at the specified index as type string. Returns true (1) if
-    // the value was set successfully.
-    ///
-    int function (
-        _cef_list_value_t* self,
-        size_t index,
-        const(cef_string_t)* value) nothrow set_string;
-
-    ///
-    // Sets the value at the specified index as type binary. Returns true (1) if
-    // the value was set successfully. If |value| is currently owned by another
-    // object then the value will be copied and the |value| reference will not
-    // change. Otherwise, ownership will be transferred to this object and the
-    // |value| reference will be invalidated.
-    ///
-    int function (
-        _cef_list_value_t* self,
-        size_t index,
-        _cef_binary_value_t* value) nothrow set_binary;
-
-    ///
-    // Sets the value at the specified index as type dict. Returns true (1) if the
-    // value was set successfully. If |value| is currently owned by another object
-    // then the value will be copied and the |value| reference will not change.
-    // Otherwise, ownership will be transferred to this object and the |value|
-    // reference will be invalidated.
-    ///
-    int function (
-        _cef_list_value_t* self,
-        size_t index,
-        _cef_dictionary_value_t* value) nothrow set_dictionary;
-
-    ///
-    // Sets the value at the specified index as type list. Returns true (1) if the
-    // value was set successfully. If |value| is currently owned by another object
-    // then the value will be copied and the |value| reference will not change.
-    // Otherwise, ownership will be transferred to this object and the |value|
-    // reference will be invalidated.
-    ///
-    int function (
-        _cef_list_value_t* self,
-        size_t index,
-        _cef_list_value_t* value) nothrow set_list;
-}
-
-alias cef_list_value_t = _cef_list_value_t;
-
-///
-// Creates a new object that is not owned by any other object.
-///
-cef_list_value_t* cef_list_value_create ();
-
-// CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=aedfa5758cbf37dff244c065d55d273231470877$
-//
-
-extern (C):
-
-///
-// WaitableEvent is a thread synchronization tool that allows one thread to wait
-// for another thread to finish some work. This is equivalent to using a
-// Lock+ConditionVariable to protect a simple boolean value. However, using
-// WaitableEvent in conjunction with a Lock to wait for a more complex state
-// change (e.g., for an item to be added to a queue) is not recommended. In that
-// case consider using a ConditionVariable instead of a WaitableEvent. It is
-// safe to create and/or signal a WaitableEvent from any thread. Blocking on a
-// WaitableEvent by calling the *wait() functions is not allowed on the browser
-// process UI or IO threads.
-///
-struct _cef_waitable_event_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Put the event in the un-signaled state.
-    ///
-    void function (_cef_waitable_event_t* self) nothrow reset;
-
-    ///
-    // Put the event in the signaled state. This causes any thread blocked on Wait
-    // to be woken up.
-    ///
-    void function (_cef_waitable_event_t* self) nothrow signal;
-
-    ///
-    // Returns true (1) if the event is in the signaled state, else false (0). If
-    // the event was created with |automatic_reset| set to true (1) then calling
-    // this function will also cause a reset.
-    ///
-    int function (_cef_waitable_event_t* self) nothrow is_signaled;
-
-    ///
-    // Wait indefinitely for the event to be signaled. This function will not
-    // return until after the call to signal() has completed. This function cannot
-    // be called on the browser process UI or IO threads.
-    ///
-    void function (_cef_waitable_event_t* self) nothrow wait;
-
-    ///
-    // Wait up to |max_ms| milliseconds for the event to be signaled. Returns true
-    // (1) if the event was signaled. A return value of false (0) does not
-    // necessarily mean that |max_ms| was exceeded. This function will not return
-    // until after the call to signal() has completed. This function cannot be
-    // called on the browser process UI or IO threads.
-    ///
-    int function (_cef_waitable_event_t* self, int64 max_ms) nothrow timed_wait;
-}
-
-alias cef_waitable_event_t = _cef_waitable_event_t;
-
-///
-// Create a new waitable event. If |automatic_reset| is true (1) then the event
-// state is automatically reset to un-signaled after a single waiting thread has
-// been released; otherwise, the state remains signaled until reset() is called
-// manually. If |initially_signaled| is true (1) then the event will start in
-// the signaled state.
-///
-cef_waitable_event_t* cef_waitable_event_create (
-    int automatic_reset,
-    int initially_signaled);
-
-// CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=f1b2b6203d45fdf76d72ea1e79fcef0bb2a26138$
-//
-
-extern (C):
-
-///
-// Information about a specific web plugin.
-///
-struct _cef_web_plugin_info_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the plugin name (i.e. Flash).
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_web_plugin_info_t* self) nothrow get_name;
-
-    ///
-    // Returns the plugin file path (DLL/bundle/library).
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_web_plugin_info_t* self) nothrow get_path;
-
-    ///
-    // Returns the version of the plugin (may be OS-specific).
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_web_plugin_info_t* self) nothrow get_version;
-
-    ///
-    // Returns a description of the plugin from the version information.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_web_plugin_info_t* self) nothrow get_description;
-}
-
-alias cef_web_plugin_info_t = _cef_web_plugin_info_t;
-
-///
-// Structure to implement for visiting web plugin information. The functions of
-// this structure will be called on the browser process UI thread.
-///
-struct _cef_web_plugin_info_visitor_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be called once for each plugin. |count| is the 0-based
-    // index for the current plugin. |total| is the total number of plugins.
-    // Return false (0) to stop visiting plugins. This function may never be
-    // called if no plugins are found.
-    ///
-    int function (
-        _cef_web_plugin_info_visitor_t* self,
-        _cef_web_plugin_info_t* info,
-        int count,
-        int total) nothrow visit;
-}
-
-alias cef_web_plugin_info_visitor_t = _cef_web_plugin_info_visitor_t;
-
-///
-// Structure to implement for receiving unstable plugin information. The
-// functions of this structure will be called on the browser process IO thread.
-///
-struct _cef_web_plugin_unstable_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be called for the requested plugin. |unstable| will be
-    // true (1) if the plugin has reached the crash count threshold of 3 times in
-    // 120 seconds.
-    ///
-    void function (
-        _cef_web_plugin_unstable_callback_t* self,
-        const(cef_string_t)* path,
-        int unstable) nothrow is_unstable;
-}
-
-alias cef_web_plugin_unstable_callback_t = _cef_web_plugin_unstable_callback_t;
-
-///
-// Implement this structure to receive notification when CDM registration is
-// complete. The functions of this structure will be called on the browser
-// process UI thread.
-///
-struct _cef_register_cdm_callback_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Method that will be called when CDM registration is complete. |result| will
-    // be CEF_CDM_REGISTRATION_ERROR_NONE if registration completed successfully.
-    // Otherwise, |result| and |error_message| will contain additional information
-    // about why registration failed.
-    ///
-    void function (
-        _cef_register_cdm_callback_t* self,
-        cef_cdm_registration_error_t result,
-        const(cef_string_t)* error_message) nothrow on_cdm_registration_complete;
+    int x;
+    int y;
 }
 
-alias cef_register_cdm_callback_t = _cef_register_cdm_callback_t;
-
-///
-// Visit web plugin information. Can be called on any thread in the browser
-// process.
-///
-void cef_visit_web_plugin_info (cef_web_plugin_info_visitor_t* visitor);
-
-///
-// Cause the plugin list to refresh the next time it is accessed regardless of
-// whether it has already been loaded. Can be called on any thread in the
-// browser process.
-///
-void cef_refresh_web_plugins ();
-
-///
-// Unregister an internal plugin. This may be undone the next time
-// cef_refresh_web_plugins() is called. Can be called on any thread in the
-// browser process.
-///
-void cef_unregister_internal_web_plugin (const(cef_string_t)* path);
-
-///
-// Register a plugin crash. Can be called on any thread in the browser process
-// but will be executed on the IO thread.
-///
-void cef_register_web_plugin_crash (const(cef_string_t)* path);
-
-///
-// Query if a plugin is unstable. Can be called on any thread in the browser
-// process.
-///
-void cef_is_web_plugin_unstable (
-    const(cef_string_t)* path,
-    cef_web_plugin_unstable_callback_t* callback);
-
-///
-// Register the Widevine CDM plugin.
-//
-// The client application is responsible for downloading an appropriate
-// platform-specific CDM binary distribution from Google, extracting the
-// contents, and building the required directory structure on the local machine.
-// The cef_browser_host_t::StartDownload function and CefZipArchive structure
-// can be used to implement this functionality in CEF. Contact Google via
-// https://www.widevine.com/contact.html for details on CDM download.
-//
-// |path| is a directory that must contain the following files:
-//   1. manifest.json file from the CDM binary distribution (see below).
-//   2. widevinecdm file from the CDM binary distribution (e.g.
-//      widevinecdm.dll on on Windows, libwidevinecdm.dylib on OS X,
-//      libwidevinecdm.so on Linux).
-//
-// If any of these files are missing or if the manifest file has incorrect
-// contents the registration will fail and |callback| will receive a |result|
-// value of CEF_CDM_REGISTRATION_ERROR_INCORRECT_CONTENTS.
-//
-// The manifest.json file must contain the following keys:
-//   A. "os": Supported OS (e.g. "mac", "win" or "linux").
-//   B. "arch": Supported architecture (e.g. "ia32" or "x64").
-//   C. "x-cdm-module-versions": Module API version (e.g. "4").
-//   D. "x-cdm-interface-versions": Interface API version (e.g. "8").
-//   E. "x-cdm-host-versions": Host API version (e.g. "8").
-//   F. "version": CDM version (e.g. "1.4.8.903").
-//   G. "x-cdm-codecs": List of supported codecs (e.g. "vp8,vp9.0,avc1").
-//
-// A through E are used to verify compatibility with the current Chromium
-// version. If the CDM is not compatible the registration will fail and
-// |callback| will receive a |result| value of
-// CEF_CDM_REGISTRATION_ERROR_INCOMPATIBLE.
-//
-// |callback| will be executed asynchronously once registration is complete.
-//
-// On Linux this function must be called before cef_initialize() and the
-// registration cannot be changed during runtime. If registration is not
-// supported at the time that cef_register_widevine_cdm() is called then
-// |callback| will receive a |result| value of
-// CEF_CDM_REGISTRATION_ERROR_NOT_SUPPORTED.
-///
-void cef_register_widevine_cdm (
-    const(cef_string_t)* path,
-    cef_register_cdm_callback_t* callback);
-
-// CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=2d04c2cc1791b90ddb9333fe830ad07042e9df2d$
-//
-
-extern (C):
-
-///
-// Structure representing the issuer or subject field of an X.509 certificate.
-///
-struct _cef_x509cert_principal_t
-{
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns a name that can be used to represent the issuer. It tries in this
-    // order: Common Name (CN), Organization Name (O) and Organizational Unit Name
-    // (OU) and returns the first non-NULL one found.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_x509cert_principal_t* self) nothrow get_display_name;
-
-    ///
-    // Returns the common name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_x509cert_principal_t* self) nothrow get_common_name;
-
-    ///
-    // Returns the locality name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_x509cert_principal_t* self) nothrow get_locality_name;
-
-    ///
-    // Returns the state or province name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_x509cert_principal_t* self) nothrow get_state_or_province_name;
-
-    ///
-    // Returns the country name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_x509cert_principal_t* self) nothrow get_country_name;
-
-    ///
-    // Retrieve the list of street addresses.
-    ///
-    void function (
-        _cef_x509cert_principal_t* self,
-        cef_string_list_t addresses) nothrow get_street_addresses;
-
-    ///
-    // Retrieve the list of organization names.
-    ///
-    void function (
-        _cef_x509cert_principal_t* self,
-        cef_string_list_t names) nothrow get_organization_names;
 
-    ///
-    // Retrieve the list of organization unit names.
-    ///
-    void function (
-        _cef_x509cert_principal_t* self,
-        cef_string_list_t names) nothrow get_organization_unit_names;
-
-    ///
-    // Retrieve the list of domain components.
-    ///
-    void function (
-        _cef_x509cert_principal_t* self,
-        cef_string_list_t components) nothrow get_domain_components;
-}
-
-alias cef_x509cert_principal_t = _cef_x509cert_principal_t;
 
 ///
-// Structure representing a X.509 certificate.
+// Structure representing a rectangle.
 ///
-struct _cef_x509certificate_t
+struct cef_rect_t
 {
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Returns the subject of the X.509 certificate. For HTTPS server certificates
-    // this represents the web server.  The common name of the subject should
-    // match the host name of the web server.
-    ///
-    _cef_x509cert_principal_t* function (
-        _cef_x509certificate_t* self) nothrow get_subject;
-
-    ///
-    // Returns the issuer of the X.509 certificate.
-    ///
-    _cef_x509cert_principal_t* function (
-        _cef_x509certificate_t* self) nothrow get_issuer;
-
-    ///
-    // Returns the DER encoded serial number for the X.509 certificate. The value
-    // possibly includes a leading 00 byte.
-    ///
-    _cef_binary_value_t* function (
-        _cef_x509certificate_t* self) nothrow get_serial_number;
-
-    ///
-    // Returns the date before which the X.509 certificate is invalid.
-    // CefTime.GetTimeT() will return 0 if no date was specified.
-    ///
-    cef_time_t function (_cef_x509certificate_t* self) nothrow get_valid_start;
-
-    ///
-    // Returns the date after which the X.509 certificate is invalid.
-    // CefTime.GetTimeT() will return 0 if no date was specified.
-    ///
-    cef_time_t function (_cef_x509certificate_t* self) nothrow get_valid_expiry;
-
-    ///
-    // Returns the DER encoded data for the X.509 certificate.
-    ///
-    _cef_binary_value_t* function (
-        _cef_x509certificate_t* self) nothrow get_derencoded;
-
-    ///
-    // Returns the PEM encoded data for the X.509 certificate.
-    ///
-    _cef_binary_value_t* function (
-        _cef_x509certificate_t* self) nothrow get_pemencoded;
-
-    ///
-    // Returns the number of certificates in the issuer chain. If 0, the
-    // certificate is self-signed.
-    ///
-    size_t function (_cef_x509certificate_t* self) nothrow get_issuer_chain_size;
-
-    ///
-    // Returns the DER encoded data for the certificate issuer chain. If we failed
-    // to encode a certificate in the chain it is still present in the array but
-    // is an NULL string.
-    ///
-    void function (
-        _cef_x509certificate_t* self,
-        size_t* chainCount,
-        _cef_binary_value_t** chain) nothrow get_derencoded_issuer_chain;
-
-    ///
-    // Returns the PEM encoded data for the certificate issuer chain. If we failed
-    // to encode a certificate in the chain it is still present in the array but
-    // is an NULL string.
-    ///
-    void function (
-        _cef_x509certificate_t* self,
-        size_t* chainCount,
-        _cef_binary_value_t** chain) nothrow get_pemencoded_issuer_chain;
+    int x;
+    int y;
+    int width;
+    int height;
 }
 
-alias cef_x509certificate_t = _cef_x509certificate_t;
-
-// CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=64f6b6477ec81b1d64517cf0af2e3b2121ff39bd$
-//
 
-extern (C):
 
 ///
-// Structure that supports the reading of XML data via the libxml streaming API.
-// The functions of this structure should only be called on the thread that
-// creates the object.
+// Structure representing a size.
 ///
-struct _cef_xml_reader_t
+struct cef_size_t
 {
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Moves the cursor to the next node in the document. This function must be
-    // called at least once to set the current cursor position. Returns true (1)
-    // if the cursor position was set successfully.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow move_to_next_node;
-
-    ///
-    // Close the document. This should be called directly to ensure that cleanup
-    // occurs on the correct thread.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow close;
-
-    ///
-    // Returns true (1) if an error has been reported by the XML parser.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow has_error;
-
-    ///
-    // Returns the error string.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_xml_reader_t* self) nothrow get_error;
-
-    // The below functions retrieve data for the node at the current cursor
-    // position.
-
-    ///
-    // Returns the node type.
-    ///
-    cef_xml_node_type_t function (_cef_xml_reader_t* self) nothrow get_type;
-
-    ///
-    // Returns the node depth. Depth starts at 0 for the root node.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow get_depth;
-
-    ///
-    // Returns the local name. See http://www.w3.org/TR/REC-xml-names/#NT-
-    // LocalPart for additional details.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_xml_reader_t* self) nothrow get_local_name;
-
-    ///
-    // Returns the namespace prefix. See http://www.w3.org/TR/REC-xml-names/ for
-    // additional details.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_xml_reader_t* self) nothrow get_prefix;
-
-    ///
-    // Returns the qualified name, equal to (Prefix:)LocalName. See
-    // http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_xml_reader_t* self) nothrow get_qualified_name;
-
-    ///
-    // Returns the URI defining the namespace associated with the node. See
-    // http://www.w3.org/TR/REC-xml-names/ for additional details.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_xml_reader_t* self) nothrow get_namespace_uri;
-
-    ///
-    // Returns the base URI of the node. See http://www.w3.org/TR/xmlbase/ for
-    // additional details.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_xml_reader_t* self) nothrow get_base_uri;
-
-    ///
-    // Returns the xml:lang scope within which the node resides. See
-    // http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_xml_reader_t* self) nothrow get_xml_lang;
-
-    ///
-    // Returns true (1) if the node represents an NULL element. <a/> is considered
-    // NULL but <a></a> is not.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow is_empty_element;
-
-    ///
-    // Returns true (1) if the node has a text value.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow has_value;
-
-    ///
-    // Returns the text value.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_xml_reader_t* self) nothrow get_value;
-
-    ///
-    // Returns true (1) if the node has attributes.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow has_attributes;
-
-    ///
-    // Returns the number of attributes.
-    ///
-    size_t function (_cef_xml_reader_t* self) nothrow get_attribute_count;
-
-    ///
-    // Returns the value of the attribute at the specified 0-based index.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_xml_reader_t* self,
-        int index) nothrow get_attribute_byindex;
-
-    ///
-    // Returns the value of the attribute with the specified qualified name.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_xml_reader_t* self,
-        const(cef_string_t)* qualifiedName) nothrow get_attribute_byqname;
-
-    ///
-    // Returns the value of the attribute with the specified local name and
-    // namespace URI.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_xml_reader_t* self,
-        const(cef_string_t)* localName,
-        const(cef_string_t)* namespaceURI) nothrow get_attribute_bylname;
-
-    ///
-    // Returns an XML representation of the current node's children.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_xml_reader_t* self) nothrow get_inner_xml;
-
-    ///
-    // Returns an XML representation of the current node including its children.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_xml_reader_t* self) nothrow get_outer_xml;
-
-    ///
-    // Returns the line number for the current node.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow get_line_number;
-
-    // Attribute nodes are not traversed by default. The below functions can be
-    // used to move the cursor to an attribute node. move_to_carrying_element()
-    // can be called afterwards to return the cursor to the carrying element. The
-    // depth of an attribute node will be 1 + the depth of the carrying element.
-
-    ///
-    // Moves the cursor to the attribute at the specified 0-based index. Returns
-    // true (1) if the cursor position was set successfully.
-    ///
-    int function (
-        _cef_xml_reader_t* self,
-        int index) nothrow move_to_attribute_byindex;
-
-    ///
-    // Moves the cursor to the attribute with the specified qualified name.
-    // Returns true (1) if the cursor position was set successfully.
-    ///
-    int function (
-        _cef_xml_reader_t* self,
-        const(cef_string_t)* qualifiedName) nothrow move_to_attribute_byqname;
-
-    ///
-    // Moves the cursor to the attribute with the specified local name and
-    // namespace URI. Returns true (1) if the cursor position was set
-    // successfully.
-    ///
-    int function (
-        _cef_xml_reader_t* self,
-        const(cef_string_t)* localName,
-        const(cef_string_t)* namespaceURI) nothrow move_to_attribute_bylname;
-
-    ///
-    // Moves the cursor to the first attribute in the current element. Returns
-    // true (1) if the cursor position was set successfully.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow move_to_first_attribute;
-
-    ///
-    // Moves the cursor to the next attribute in the current element. Returns true
-    // (1) if the cursor position was set successfully.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow move_to_next_attribute;
-
-    ///
-    // Moves the cursor back to the carrying element. Returns true (1) if the
-    // cursor position was set successfully.
-    ///
-    int function (_cef_xml_reader_t* self) nothrow move_to_carrying_element;
+    int width;
+    int height;
 }
 
-alias cef_xml_reader_t = _cef_xml_reader_t;
-
-///
-// Create a new cef_xml_reader_t object. The returned object's functions can
-// only be called from the thread that created the object.
-///
-cef_xml_reader_t* cef_xml_reader_create (
-    _cef_stream_reader_t* stream,
-    cef_xml_encoding_type_t encodingType,
-    const(cef_string_t)* URI);
-
-// CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the name Chromium Embedded
-// Framework nor the names of its contributors may be used to endorse
-// or promote products derived from this software without specific prior
-// written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ---------------------------------------------------------------------------
-//
-// This file was generated by the CEF translator tool and should not edited
-// by hand. See the translator.README.txt file in the tools directory for
-// more information.
-//
-// $hash=f8b7ec1654c7d62153e2670b52ed18eb4c9c58d5$
-//
 
-extern (C):
 
 ///
-// Structure that supports the reading of zip archives via the zlib unzip API.
-// The functions of this structure should only be called on the thread that
-// creates the object.
+// Structure representing insets.
 ///
-struct _cef_zip_reader_t
+struct cef_insets_t
 {
-    ///
-    // Base structure.
-    ///
-    cef_base_ref_counted_t base;
-
-    ///
-    // Moves the cursor to the first file in the archive. Returns true (1) if the
-    // cursor position was set successfully.
-    ///
-    int function (_cef_zip_reader_t* self) nothrow move_to_first_file;
-
-    ///
-    // Moves the cursor to the next file in the archive. Returns true (1) if the
-    // cursor position was set successfully.
-    ///
-    int function (_cef_zip_reader_t* self) nothrow move_to_next_file;
-
-    ///
-    // Moves the cursor to the specified file in the archive. If |caseSensitive|
-    // is true (1) then the search will be case sensitive. Returns true (1) if the
-    // cursor position was set successfully.
-    ///
-    int function (
-        _cef_zip_reader_t* self,
-        const(cef_string_t)* fileName,
-        int caseSensitive) nothrow move_to_file;
-
-    ///
-    // Closes the archive. This should be called directly to ensure that cleanup
-    // occurs on the correct thread.
-    ///
-    int function (_cef_zip_reader_t* self) nothrow close;
-
-    // The below functions act on the file at the current cursor position.
-
-    ///
-    // Returns the name of the file.
-    ///
-    // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (_cef_zip_reader_t* self) nothrow get_file_name;
-
-    ///
-    // Returns the uncompressed size of the file.
-    ///
-    int64 function (_cef_zip_reader_t* self) nothrow get_file_size;
-
-    ///
-    // Returns the last modified timestamp for the file.
-    ///
-    cef_time_t function (_cef_zip_reader_t* self) nothrow get_file_last_modified;
-
-    ///
-    // Opens the file for reading of uncompressed data. A read password may
-    // optionally be specified.
-    ///
-    int function (
-        _cef_zip_reader_t* self,
-        const(cef_string_t)* password) nothrow open_file;
-
-    ///
-    // Closes the file.
-    ///
-    int function (_cef_zip_reader_t* self) nothrow close_file;
-
-    ///
-    // Read uncompressed file contents into the specified buffer. Returns < 0 if
-    // an error occurred, 0 if at the end of file, or the number of bytes read.
-    ///
-    int function (
-        _cef_zip_reader_t* self,
-        void* buffer,
-        size_t bufferSize) nothrow read_file;
-
-    ///
-    // Returns the current offset in the uncompressed file contents.
-    ///
-    int64 function (_cef_zip_reader_t* self) nothrow tell;
-
-    ///
-    // Returns true (1) if at end of the file contents.
-    ///
-    int function (_cef_zip_reader_t* self) nothrow eof;
+    int top;
+    int left;
+    int bottom;
+    int right;
 }
 
-alias cef_zip_reader_t = _cef_zip_reader_t;
 
-///
-// Create a new cef_zip_reader_t object. The returned object's functions can
-// only be called from the thread that created the object.
-///
-cef_zip_reader_t* cef_zip_reader_create (_cef_stream_reader_t* stream);
 
-// CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
+// CEF_INCLUDE_INTERNAL_CEF_TYPES_GEOMETRY_H_
 // Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -14705,6 +1662,30 @@ extern (C):
 // in a known order. Equivalent to the SkColor type.
 alias cef_color_t = uint;
 
+// Return the alpha byte from a cef_color_t value.
+
+
+// Return the red byte from a cef_color_t value.
+
+
+// Return the green byte from a cef_color_t value.
+
+
+// Return the blue byte from a cef_color_t value.
+
+
+// Return an cef_color_t value with the specified byte component values.
+
+
+// Return an int64 value with the specified low and high int32 component values.
+
+
+// Return the low int32 value from an int64 value.
+
+
+// Return the high int32 value from an int64 value.
+
+
 ///
 // Log severity levels.
 ///
@@ -14778,7 +1759,7 @@ enum cef_state_t
 // values. Many of these and other settings can also configured using command-
 // line switches.
 ///
-struct _cef_settings_t
+struct cef_settings_t
 {
     ///
     // Size of this structure.
@@ -14870,7 +1851,9 @@ struct _cef_settings_t
     // in-memory caches are used for storage and no data is persisted to disk.
     // HTML5 databases such as localStorage will only persist across sessions if a
     // cache path is specified. Can be overridden for individual CefRequestContext
-    // instances via the CefRequestContextSettings.cache_path value.
+    // instances via the CefRequestContextSettings.cache_path value. When using
+    // the Chrome runtime the "default" profile will be used if |cache_path| and
+    // |root_cache_path| have the same value.
     ///
     cef_string_t cache_path;
 
@@ -14886,13 +1869,14 @@ struct _cef_settings_t
     cef_string_t root_cache_path;
 
     ///
-    // The location where user data such as spell checking dictionary files will
-    // be stored on disk. If this value is empty then the default
-    // platform-specific user data directory will be used ("~/.cef_user_data"
-    // directory on Linux, "~/Library/Application Support/CEF/User Data" directory
-    // on Mac OS X, "Local Settings\Application Data\CEF\User Data" directory
-    // under the user profile directory on Windows). If this value is non-empty
-    // then it must be an absolute path.
+    // The location where user data such as the Widevine CDM module and spell
+    // checking dictionary files will be stored on disk. If this value is empty
+    // then the default platform-specific user data directory will be used
+    // ("~/.config/cef_user_data" directory on Linux, "~/Library/Application
+    // Support/CEF/User Data" directory on MacOS, "AppData\Local\CEF\User Data"
+    // directory under the user profile directory on Windows). If this value is
+    // non-empty then it must be an absolute path. When using the Chrome runtime
+    // this value will be ignored in favor of the |root_cache_path| value.
     ///
     cef_string_t user_data_path;
 
@@ -14929,9 +1913,9 @@ struct _cef_settings_t
     // Value that will be inserted as the product portion of the default
     // User-Agent string. If empty the Chromium product version will be used. If
     // |userAgent| is specified this value will be ignored. Also configurable
-    // using the "product-version" command-line switch.
+    // using the "user-agent-product" command-line switch.
     ///
-    cef_string_t product_version;
+    cef_string_t user_agent_product;
 
     ///
     // The locale string that will be passed to WebKit. If empty the default
@@ -14945,7 +1929,7 @@ struct _cef_settings_t
     ///
     // The directory and file name to use for the debug log. If empty a default
     // log file name and location will be used. On Windows and Linux a "debug.log"
-    // file will be written in the main executable directory. On Mac OS X a
+    // file will be written in the main executable directory. On MacOS a
     // "~/Library/Logs/<app name>_debug.log" file will be written where <app name>
     // is the name of the main app executable. Also configurable using the
     // "log-file" command-line switch.
@@ -14970,10 +1954,10 @@ struct _cef_settings_t
 
     ///
     // The fully qualified path for the resources directory. If this value is
-    // empty the cef.pak and/or devtools_resources.pak files must be located in
-    // the module directory on Windows/Linux or the app bundle Resources directory
-    // on Mac OS X. If this value is non-empty then it must be an absolute path.
-    // Also configurable using the "resources-dir-path" command-line switch.
+    // empty the *.pak files must be located in the module directory on
+    // Windows/Linux or the app bundle Resources directory on MacOS. If this
+    // value is non-empty then it must be an absolute path. Also configurable
+    // using the "resources-dir-path" command-line switch.
     ///
     cef_string_t resources_dir_path;
 
@@ -14981,9 +1965,9 @@ struct _cef_settings_t
     // The fully qualified path for the locales directory. If this value is empty
     // the locales directory must be located in the module directory. If this
     // value is non-empty then it must be an absolute path. This value is ignored
-    // on Mac OS X where pack files are always loaded from the app bundle
-    // Resources directory. Also configurable using the "locales-dir-path"
-    // command-line switch.
+    // on MacOS where pack files are always loaded from the app bundle Resources
+    // directory. Also configurable using the "locales-dir-path" command-line
+    // switch.
     ///
     cef_string_t locales_dir_path;
 
@@ -15014,17 +1998,6 @@ struct _cef_settings_t
     ///
     int uncaught_exception_stack_size;
 
-    ///
-    // Set to true (1) to ignore errors related to invalid SSL certificates.
-    // Enabling this setting can lead to potential security vulnerabilities like
-    // "man in the middle" attacks. Applications that load content from the
-    // internet should not enable this setting. Also configurable using the
-    // "ignore-certificate-errors" command-line switch. Can be overridden for
-    // individual CefRequestContext instances via the
-    // CefRequestContextSettings.ignore_certificate_errors value.
-    ///
-    int ignore_certificate_errors;
-
     ///
     // Background color used for the browser before a document is loaded and when
     // no document color is specified. The alpha component must be either fully
@@ -15047,6 +2020,20 @@ struct _cef_settings_t
     ///
     cef_string_t accept_language_list;
 
+    ///
+    // Comma delimited list of schemes supported by the associated
+    // CefCookieManager. If |cookieable_schemes_exclude_defaults| is false (0) the
+    // default schemes ("http", "https", "ws" and "wss") will also be supported.
+    // Specifying a |cookieable_schemes_list| value and setting
+    // |cookieable_schemes_exclude_defaults| to true (1) will disable all loading
+    // and saving of cookies for this manager. Can be overridden
+    // for individual CefRequestContext instances via the
+    // CefRequestContextSettings.cookieable_schemes_list and
+    // CefRequestContextSettings.cookieable_schemes_exclude_defaults values.
+    ///
+    cef_string_t cookieable_schemes_list;
+    int cookieable_schemes_exclude_defaults;
+
     ///
     // GUID string used for identifying the application. This is passed to the
     // system AV function for scanning downloaded files. By default, the GUID
@@ -15056,13 +2043,13 @@ struct _cef_settings_t
     cef_string_t application_client_id_for_file_scanning;
 }
 
-alias cef_settings_t = _cef_settings_t;
+
 
 ///
 // Request context initialization settings. Specify NULL or 0 to get the
 // recommended default values.
 ///
-struct _cef_request_context_settings_t
+struct cef_request_context_settings_t
 {
     ///
     // Size of this structure.
@@ -15099,16 +2086,6 @@ struct _cef_request_context_settings_t
     ///
     int persist_user_preferences;
 
-    ///
-    // Set to true (1) to ignore errors related to invalid SSL certificates.
-    // Enabling this setting can lead to potential security vulnerabilities like
-    // "man in the middle" attacks. Applications that load content from the
-    // internet should not enable this setting. Can be set globally using the
-    // CefSettings.ignore_certificate_errors value. This value will be ignored if
-    // |cache_path| matches the CefSettings.cache_path value.
-    ///
-    int ignore_certificate_errors;
-
     ///
     // Comma delimited ordered list of language codes without any whitespace that
     // will be used in the "Accept-Language" HTTP header. Can be set globally
@@ -15118,9 +2095,21 @@ struct _cef_request_context_settings_t
     // ignored if |cache_path| matches the CefSettings.cache_path value.
     ///
     cef_string_t accept_language_list;
+
+    ///
+    // Comma delimited list of schemes supported by the associated
+    // CefCookieManager. If |cookieable_schemes_exclude_defaults| is false (0) the
+    // default schemes ("http", "https", "ws" and "wss") will also be supported.
+    // Specifying a |cookieable_schemes_list| value and setting
+    // |cookieable_schemes_exclude_defaults| to true (1) will disable all loading
+    // and saving of cookies for this manager. These values will be ignored if
+    // |cache_path| matches the CefSettings.cache_path value.
+    ///
+    cef_string_t cookieable_schemes_list;
+    int cookieable_schemes_exclude_defaults;
 }
 
-alias cef_request_context_settings_t = _cef_request_context_settings_t;
+
 
 ///
 // Browser initialization settings. Specify NULL or 0 to get the recommended
@@ -15128,7 +2117,7 @@ alias cef_request_context_settings_t = _cef_request_context_settings_t;
 // tested. Many of these and other settings can also configured using command-
 // line switches.
 ///
-struct _cef_browser_settings_t
+struct cef_browser_settings_t
 {
     ///
     // Size of this structure.
@@ -15207,26 +2196,6 @@ struct _cef_browser_settings_t
     ///
     cef_state_t plugins;
 
-    ///
-    // Controls whether file URLs will have access to all URLs. Also configurable
-    // using the "allow-universal-access-from-files" command-line switch.
-    ///
-    cef_state_t universal_access_from_file_urls;
-
-    ///
-    // Controls whether file URLs will have access to other file URLs. Also
-    // configurable using the "allow-access-from-files" command-line switch.
-    ///
-    cef_state_t file_access_from_file_urls;
-
-    ///
-    // Controls whether web security restrictions (same-origin policy) will be
-    // enforced. Disabling this setting is not recommend as it will allow risky
-    // security behavior such as cross-site scripting (XSS). Also configurable
-    // using the "disable-web-security" command-line switch.
-    ///
-    cef_state_t web_security;
-
     ///
     // Controls whether image URLs will be loaded from the network. A cached image
     // will still be rendered if requested. Also configurable using the
@@ -15265,12 +2234,6 @@ struct _cef_browser_settings_t
     ///
     cef_state_t databases;
 
-    ///
-    // Controls whether the application cache can be used. Also configurable using
-    // the "disable-application-cache" command-line switch.
-    ///
-    cef_state_t application_cache;
-
     ///
     // Controls whether WebGL can be used. Note that WebGL requires hardware
     // support and may not work on all systems even when enabled. Also
@@ -15293,13 +2256,13 @@ struct _cef_browser_settings_t
     ///
     // Comma delimited ordered list of language codes without any whitespace that
     // will be used in the "Accept-Language" HTTP header. May be set globally
-    // using the CefBrowserSettings.accept_language_list value. If both values are
+    // using the CefSettings.accept_language_list value. If both values are
     // empty then "en-US,en" will be used.
     ///
     cef_string_t accept_language_list;
 }
 
-alias cef_browser_settings_t = _cef_browser_settings_t;
+
 
 ///
 // Return value types.
@@ -15325,7 +2288,7 @@ enum cef_return_value_t
 ///
 // URL component parts.
 ///
-struct _cef_urlparts_t
+struct cef_urlparts_t
 {
     ///
     // The complete URL specification.
@@ -15382,7 +2345,7 @@ struct _cef_urlparts_t
     cef_string_t fragment;
 }
 
-alias cef_urlparts_t = _cef_urlparts_t;
+
 
 ///
 // Cookie priority values.
@@ -15408,7 +2371,7 @@ enum cef_cookie_same_site_t
 ///
 // Cookie information.
 ///
-struct _cef_cookie_t
+struct cef_cookie_t
 {
     ///
     // The cookie name.
@@ -15472,7 +2435,7 @@ struct _cef_cookie_t
     cef_cookie_priority_t priority;
 }
 
-alias cef_cookie_t = _cef_cookie_t;
+
 
 ///
 // Process termination status values.
@@ -15544,7 +2507,7 @@ enum cef_path_key_t
 
     ///
     // "Application Data" directory under the user profile directory on Windows
-    // and "~/Library/Application Support" directory on Mac OS X.
+    // and "~/Library/Application Support" directory on MacOS.
     ///
     PK_USER_DATA = 7,
 
@@ -15601,7 +2564,6 @@ enum cef_errorcode_t
     ERR_CLEARTEXT_NOT_PERMITTED = -29,
     ERR_BLOCKED_BY_CSP = -30,
     ERR_H2_OR_QUIC_REQUIRED = -31,
-    ERR_INSECURE_PRIVATE_NETWORK_REQUEST = -32,
     ERR_CONNECTION_CLOSED = -100,
     ERR_CONNECTION_RESET = -101,
     ERR_CONNECTION_REFUSED = -102,
@@ -15759,91 +2721,89 @@ enum cef_errorcode_t
     ERR_CACHE_OPERATION_NOT_SUPPORTED = -403,
     ERR_CACHE_OPEN_FAILURE = -404,
     ERR_CACHE_CREATE_FAILURE = -405,
-    ERR_CACHE_RACE = -406,
 
     ///
     // Supported certificate status code values. See net\cert\cert_status_flags.h
+    ERR_CACHE_RACE = -406,
     // for more information. CERT_STATUS_NONE is new in CEF because we use an
     // enum while cert_status_flags.h uses a typedef and static const variables.
-    ERR_CACHE_CHECKSUM_READ_FAILURE = -407,
     ///
+    ERR_CACHE_CHECKSUM_READ_FAILURE = -407,
 
     // 1 << 3 is reserved for ERR_CERT_CONTAINS_ERRORS (not useful with WinHTTP).
     ERR_CACHE_CHECKSUM_MISMATCH = -408,
-    ERR_CACHE_LOCK_TIMEOUT = -409,
 
     // 1 << 9 was used for CERT_STATUS_NOT_IN_DNS
-    ERR_CACHE_AUTH_FAILURE_AFTER_READ = -410,
+    ERR_CACHE_LOCK_TIMEOUT = -409,
 
     // 1 << 12 was used for CERT_STATUS_WEAK_DH_KEY
+    ERR_CACHE_AUTH_FAILURE_AFTER_READ = -410,
 
     // Bits 16 to 31 are for non-error statuses.
-    ERR_CACHE_ENTRY_NOT_SUITABLE = -411,
 
     // Bit 18 was CERT_STATUS_IS_DNSSEC
+    ERR_CACHE_ENTRY_NOT_SUITABLE = -411,
     ERR_CACHE_DOOM_FAILURE = -412,
-    ERR_CACHE_OPEN_OR_CREATE_FAILURE = -413,
 
     ///
     // The manner in which a link click should be opened. These constants match
-    ERR_INSECURE_RESPONSE = -501,
     // their equivalents in Chromium's window_open_disposition.h and should not be
+    ERR_CACHE_OPEN_OR_CREATE_FAILURE = -413,
     // renumbered.
     ///
+    ERR_INSECURE_RESPONSE = -501,
     ERR_NO_PRIVATE_KEY_FOR_CERT = -502,
-    ERR_ADD_USER_CERT_FAILED = -503,
 
     ///
-    ERR_INVALID_SIGNED_EXCHANGE = -504,
     // "Verb" of a drag-and-drop operation as negotiated between the source and
+    ERR_ADD_USER_CERT_FAILED = -503,
     // destination. These constants match their equivalents in WebCore's
-    ERR_INVALID_WEB_BUNDLE = -505,
+    ERR_INVALID_SIGNED_EXCHANGE = -504,
     // DragActions.h and should not be renumbered.
     ///
+    ERR_INVALID_WEB_BUNDLE = -505,
     ERR_TRUST_TOKEN_OPERATION_FAILED = -506,
 
     ///
     // Input mode of a virtual keyboard. These constants match their equivalents
-    ERR_TRUST_TOKEN_OPERATION_CACHE_HIT = -507,
     // in Chromium's text_input_mode.h and should not be renumbered.
     // See https://html.spec.whatwg.org/#input-modalities:-the-inputmode-attribute
     ///
-    ERR_FTP_FAILED = -601,
-    ERR_FTP_SERVICE_UNAVAILABLE = -602,
-    ERR_FTP_TRANSFER_ABORTED = -603,
+    ERR_TRUST_TOKEN_OPERATION_SUCCESS_WITHOUT_SENDING_REQUEST = -507,
 
     ///
     // V8 access control values.
+    ERR_FTP_FAILED = -601,
     ///
-    ERR_FTP_FILE_BUSY = -604,
+    ERR_FTP_SERVICE_UNAVAILABLE = -602,
 
     ///
     // V8 property attribute values.
-    ERR_FTP_SYNTAX_ERROR = -605,
+    ERR_FTP_TRANSFER_ABORTED = -603,
     ///
 
     // Writeable, Enumerable,
-    ERR_FTP_COMMAND_NOT_SUPPORTED = -606,
     //   Configurable
+    ERR_FTP_FILE_BUSY = -604,
     // Not writeable
-    ERR_FTP_BAD_COMMAND_SEQUENCE = -607,
     // Not enumerable
+    ERR_FTP_SYNTAX_ERROR = -605,
     // Not configurable
-    ERR_PKCS12_IMPORT_BAD_PASSWORD = -701,
 
     ///
     // Post data elements may represent either bytes or files.
-    ERR_PKCS12_IMPORT_FAILED = -702,
+    ERR_FTP_COMMAND_NOT_SUPPORTED = -606,
     ///
-    ERR_IMPORT_CA_CERT_NOT_CA = -703,
 
     ///
+    ERR_FTP_BAD_COMMAND_SEQUENCE = -607,
     // Resource type for a request.
     ///
 
     ///
     // Top level page.
     ///
+    ERR_PKCS12_IMPORT_BAD_PASSWORD = -701,
 
     ///
     // Frame or iframe.
@@ -15851,7 +2811,7 @@ enum cef_errorcode_t
 
     ///
     // CSS stylesheet.
-    ERR_IMPORT_CERT_ALREADY_EXISTS = -704,
+    ERR_PKCS12_IMPORT_FAILED = -702,
     ///
 
     ///
@@ -15859,8 +2819,8 @@ enum cef_errorcode_t
     ///
 
     ///
+    ERR_IMPORT_CA_CERT_NOT_CA = -703,
     // Image (jpg/gif/png/etc).
-    ERR_IMPORT_CA_CERT_FAILED = -705,
     ///
 
     ///
@@ -15869,15 +2829,14 @@ enum cef_errorcode_t
 
     ///
     // Some other subresource. This is the default type if the actual type is
-    ERR_IMPORT_SERVER_CERT_FAILED = -706,
     // unknown.
     ///
-    ERR_PKCS12_IMPORT_INVALID_MAC = -707,
 
     ///
+    ERR_IMPORT_CERT_ALREADY_EXISTS = -704,
     // Object (or embed) tag for a plugin, or a resource that a plugin requested.
-    ERR_PKCS12_IMPORT_INVALID_FILE = -708,
     ///
+    ERR_IMPORT_CA_CERT_FAILED = -705,
 
     ///
     // Media resource.
@@ -15885,13 +2844,13 @@ enum cef_errorcode_t
 
     ///
     // Main resource of a dedicated worker.
-    ERR_PKCS12_IMPORT_UNSUPPORTED = -709,
+    ERR_IMPORT_SERVER_CERT_FAILED = -706,
     ///
 
     ///
     // Main resource of a shared worker.
-    ERR_KEY_GENERATION_FAILED = -710,
     ///
+    ERR_PKCS12_IMPORT_INVALID_MAC = -707,
 
     ///
     // Explicitly requested prefetch.
@@ -15900,7 +2859,7 @@ enum cef_errorcode_t
     ///
     // Favicon.
     ///
-    ERR_PRIVATE_KEY_EXPORT_FAILED = -712,
+    ERR_PKCS12_IMPORT_INVALID_FILE = -708,
 
     ///
     // XMLHttpRequest.
@@ -15909,30 +2868,41 @@ enum cef_errorcode_t
     ///
     // A request for a <ping>
     ///
-    ERR_SELF_SIGNED_CERT_GENERATION_FAILED = -713,
+    ERR_PKCS12_IMPORT_UNSUPPORTED = -709,
 
     ///
     // Main resource of a service worker.
     ///
+    ERR_KEY_GENERATION_FAILED = -710,
 
     ///
     // A report of Content Security Policy violations.
-    ERR_CERT_DATABASE_CHANGED = -714,
     ///
 
     ///
     // A resource that a plugin requested.
+    ERR_PRIVATE_KEY_EXPORT_FAILED = -712,
+    ///
+
+    ///
+    // A main-frame service worker navigation preload request.
+    ERR_SELF_SIGNED_CERT_GENERATION_FAILED = -713,
+    ///
+
+    ///
+    // A sub-frame service worker navigation preload request.
+    ERR_CERT_DATABASE_CHANGED = -714,
     ///
 
     ///
-    ERR_DNS_MALFORMED_RESPONSE = -800,
     // Transition type for a request. Made up of one source value and 0 or more
-    ERR_DNS_SERVER_REQUIRES_TCP = -801,
     // qualifiers.
+    ERR_DNS_MALFORMED_RESPONSE = -800,
     ///
 
     ///
     // Source is a link click or the JavaScript window.open function. This is
+    ERR_DNS_SERVER_REQUIRES_TCP = -801,
     // also the default value for requests like sub-resource loads that are not
     // navigations.
     ///
@@ -15944,25 +2914,35 @@ enum cef_errorcode_t
 
     ///
     // Source is a subframe navigation. This is any content that is automatically
-    ERR_DNS_SERVER_FAILED = -802,
     // loaded in a non-toplevel frame. For example, if a page consists of several
-    ERR_DNS_TIMED_OUT = -803,
+    ERR_DNS_SERVER_FAILED = -802,
     // frames containing ads, those ad URLs will have this transition type.
+    ERR_DNS_TIMED_OUT = -803,
     // The user may not even realize the content in these pages is a separate
     // frame, so may not care about the URL.
     ///
 
     ///
     // Source is a subframe navigation explicitly requested by the user that will
-    ERR_DNS_CACHE_MISS = -804,
     // generate new navigation entries in the back/forward list. These are
-    ERR_DNS_SEARCH_EMPTY = -805,
+    ERR_DNS_CACHE_MISS = -804,
     // probably more important than frames that were automatically loaded in
-    ERR_DNS_SORT_ERROR = -806,
+    ERR_DNS_SEARCH_EMPTY = -805,
     // the background because the user probably cares about the fact that this
+    ERR_DNS_SORT_ERROR = -806,
     // link was loaded.
     ///
-    ERR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED = -808
+
+    ///
+    // Source is a form submission by the user. NOTE: In some situations
+    // submitting a form does not result in this transition type. This can happen
+    ERR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED = -808,
+    // if the form uses a script to submit the contents.
+    ///
+
+    ///
+    // Source is a "reload" of the page via the Reload function or by re-visiting
+    ERR_DNS_NAME_HTTPS_ONLY = -809
 }
 
 enum cef_cert_status_t
@@ -16069,7 +3049,9 @@ enum cef_resource_type_t
     RT_PING = 14,
     RT_SERVICE_WORKER = 15,
     RT_CSP_REPORT = 16,
-    RT_PLUGIN_RESOURCE = 17
+    RT_PLUGIN_RESOURCE = 17,
+    RT_NAVIGATION_PRELOAD_MAIN_FRAME = 19,
+    RT_NAVIGATION_PRELOAD_SUB_FRAME = 20
 }
 
 enum cef_transition_type_t
@@ -16078,16 +3060,7 @@ enum cef_transition_type_t
     TT_EXPLICIT = 1,
     TT_AUTO_SUBFRAME = 3,
     TT_MANUAL_SUBFRAME = 4,
-
-    ///
-    // Source is a form submission by the user. NOTE: In some situations
-    // submitting a form does not result in this transition type. This can happen
-    // if the form uses a script to submit the contents.
-    ///
     TT_FORM_SUBMIT = 7,
-
-    ///
-    // Source is a "reload" of the page via the Reload function or by re-visiting
     // the same URL. NOTE: This is distinct from the concept of whether a
     // particular load uses "reload semantics" (i.e. bypasses cached data).
     ///
@@ -16246,69 +3219,9 @@ enum cef_urlrequest_status_t
     UR_FAILED = 4
 }
 
-///
-// Structure representing a point.
-///
-struct _cef_point_t
-{
-    int x;
-    int y;
-}
-
-alias cef_point_t = _cef_point_t;
-
-///
-// Structure representing a rectangle.
-///
-struct _cef_rect_t
-{
-    int x;
-    int y;
-    int width;
-    int height;
-}
-
-alias cef_rect_t = _cef_rect_t;
-
-///
-// Structure representing a size.
-///
-struct _cef_size_t
-{
-    int width;
-    int height;
-}
-
-alias cef_size_t = _cef_size_t;
-
-///
-// Structure representing a range.
-///
-struct _cef_range_t
-{
-    int from;
-    int to;
-}
-
-alias cef_range_t = _cef_range_t;
-
-///
-// Structure representing insets.
-///
-struct _cef_insets_t
-{
-    int top;
-    int left;
-    int bottom;
-    int right;
-}
-
-alias cef_insets_t = _cef_insets_t;
-
-///
 // Structure representing a draggable region.
 ///
-struct _cef_draggable_region_t
+struct cef_draggable_region_t
 {
     ///
     // Bounds of the region.
@@ -16321,7 +3234,7 @@ struct _cef_draggable_region_t
     int draggable;
 }
 
-alias cef_draggable_region_t = _cef_draggable_region_t;
+
 
 ///
 // Existing process IDs.
@@ -16362,7 +3275,6 @@ enum cef_thread_id_t
     // CefShutdown() are guaranteed to run.
     ///
     TID_FILE_BACKGROUND = 1,
-    TID_FILE = TID_FILE_BACKGROUND,
 
     ///
     // Used for blocking tasks (e.g. file system access) that affect UI or
@@ -16512,7 +3424,7 @@ enum cef_jsdialog_type_t
 // passed as a parameter to CefRenderHandler::GetScreenInfo and should be filled
 // in by the client.
 ///
-struct _cef_screen_info_t
+struct cef_screen_info_t
 {
     ///
     // Device scale factor. Specifies the ratio between physical and logical
@@ -16564,7 +3476,7 @@ struct _cef_screen_info_t
     cef_rect_t available_rect;
 }
 
-alias cef_screen_info_t = _cef_screen_info_t;
+
 
 ///
 // Supported menu IDs. Non-English translations can be provided for the
@@ -16604,7 +3516,7 @@ enum cef_menu_id_t
     MENU_ID_ADD_TO_DICTIONARY = 206,
 
     // Custom menu items originating from the renderer process. For example,
-    // plugin placeholder menu items or Flash menu items.
+    // plugin placeholder menu items.
     MENU_ID_CUSTOM_FIRST = 220,
     MENU_ID_CUSTOM_LAST = 250,
 
@@ -16628,7 +3540,7 @@ enum cef_mouse_button_type_t
 ///
 // Structure representing mouse event information.
 ///
-struct _cef_mouse_event_t
+struct cef_mouse_event_t
 {
     ///
     // X coordinate relative to the left side of the view.
@@ -16647,7 +3559,7 @@ struct _cef_mouse_event_t
     uint32 modifiers;
 }
 
-alias cef_mouse_event_t = _cef_mouse_event_t;
+
 
 ///
 // Touch points states types.
@@ -16675,7 +3587,7 @@ enum cef_pointer_type_t
 ///
 // Structure representing touch event information.
 ///
-struct _cef_touch_event_t
+struct cef_touch_event_t
 {
     ///
     // Id of a touch point. Must be unique per touch, can be any number except -1.
@@ -16735,7 +3647,7 @@ struct _cef_touch_event_t
     cef_pointer_type_t pointer_type;
 }
 
-alias cef_touch_event_t = _cef_touch_event_t;
+
 
 ///
 // Paint element types.
@@ -16765,7 +3677,8 @@ enum cef_event_flags_t
     EVENTFLAG_IS_KEY_PAD = 1 << 9,
     EVENTFLAG_IS_LEFT = 1 << 10,
     EVENTFLAG_IS_RIGHT = 1 << 11,
-    EVENTFLAG_ALTGR_DOWN = 1 << 12
+    EVENTFLAG_ALTGR_DOWN = 1 << 12,
+    EVENTFLAG_IS_REPEAT = 1 << 13
 }
 
 ///
@@ -16914,7 +3827,7 @@ enum cef_key_event_type_t
 ///
 // Structure representing keyboard event information.
 ///
-struct _cef_key_event_t
+struct cef_key_event_t
 {
     ///
     // The type of keyboard event.
@@ -16965,7 +3878,7 @@ struct _cef_key_event_t
     int focus_on_editable_field;
 }
 
-alias cef_key_event_t = _cef_key_event_t;
+
 
 ///
 // Focus sources.
@@ -17031,7 +3944,7 @@ enum cef_xml_node_type_t
 ///
 // Popup window features.
 ///
-struct _cef_popup_features_t
+struct cef_popup_features_t
 {
     int x;
     int xSet;
@@ -17048,7 +3961,7 @@ struct _cef_popup_features_t
     int scrollbarsVisible;
 }
 
-alias cef_popup_features_t = _cef_popup_features_t;
+
 
 ///
 // DOM document types.
@@ -17261,7 +4174,7 @@ enum cef_cursor_type_t
 // |size.width|*|size.height|*4 bytes in size and represents a BGRA image with
 // an upper-left origin.
 ///
-struct _cef_cursor_info_t
+struct cef_cursor_info_t
 {
     cef_point_t hotspot;
     float image_scale_factor;
@@ -17269,7 +4182,7 @@ struct _cef_cursor_info_t
     cef_size_t size;
 }
 
-alias cef_cursor_info_t = _cef_cursor_info_t;
+
 
 ///
 // URI unescape rules passed to CefURIDecode().
@@ -17402,7 +4315,7 @@ enum cef_pdf_print_margin_type_t
 ///
 // Structure representing PDF print settings.
 ///
-struct _cef_pdf_print_settings_t
+struct cef_pdf_print_settings_t
 {
     ///
     // Page title to display in the header. Only used if |header_footer_enabled|
@@ -17467,7 +4380,7 @@ struct _cef_pdf_print_settings_t
     int backgrounds_enabled;
 }
 
-alias cef_pdf_print_settings_t = _cef_pdf_print_settings_t;
+
 
 ///
 // Supported UI scale factors for the platform. SCALE_FACTOR_NONE is used for
@@ -17700,7 +4613,7 @@ enum cef_cross_axis_alignment_t
 ///
 // Settings used when initializing a CefBoxLayout.
 ///
-struct _cef_box_layout_settings_t
+struct cef_box_layout_settings_t
 {
     ///
     // If true (1) the layout will be horizontal, otherwise the layout will be
@@ -17755,7 +4668,7 @@ struct _cef_box_layout_settings_t
     int default_flex;
 }
 
-alias cef_box_layout_settings_t = _cef_box_layout_settings_t;
+
 
 ///
 // Specifies the button display state.
@@ -17923,31 +4836,16 @@ enum cef_scheme_options_t
 }
 
 ///
-// Error codes for CDM registration. See cef_web_plugin.h for details.
+// Structure representing a range.
 ///
-enum cef_cdm_registration_error_t
+struct cef_range_t
 {
-    ///
-    // No error. Registration completed successfully.
-    ///
-    CEF_CDM_REGISTRATION_ERROR_NONE = 0,
-
-    ///
-    // Required files or manifest contents are missing.
-    ///
-    CEF_CDM_REGISTRATION_ERROR_INCORRECT_CONTENTS = 1,
-
-    ///
-    // The CDM is incompatible with the current Chromium version.
-    ///
-    CEF_CDM_REGISTRATION_ERROR_INCOMPATIBLE = 2,
-
-    ///
-    // CDM registration is not supported at this time.
-    ///
-    CEF_CDM_REGISTRATION_ERROR_NOT_SUPPORTED = 3
+    int from;
+    int to;
 }
 
+
+
 ///
 // Composition underline style.
 ///
@@ -17964,7 +4862,7 @@ enum cef_composition_underline_style_t
 // wrapper around Blink's WebCompositionUnderline class and should be kept in
 // sync with that.
 ///
-struct _cef_composition_underline_t
+struct cef_composition_underline_t
 {
     ///
     // Underline character range.
@@ -17992,7 +4890,7 @@ struct _cef_composition_underline_t
     cef_composition_underline_style_t style;
 }
 
-alias cef_composition_underline_t = _cef_composition_underline_t;
+
 
 ///
 // Enumerates the various representations of the ordering of audio channels.
@@ -18109,7 +5007,7 @@ enum cef_channel_layout_t
 ///
 // Structure representing the audio parameters for setting up the audio handler.
 ///
-struct _cef_audio_parameters_t
+struct cef_audio_parameters_t
 {
     ///
     // Layout of the audio channels
@@ -18127,7 +5025,7 @@ struct _cef_audio_parameters_t
     int frames_per_buffer;
 }
 
-alias cef_audio_parameters_t = _cef_audio_parameters_t;
+
 
 ///
 // Result codes for CefMediaRouter::CreateRoute. Should be kept in sync with
@@ -18144,8 +5042,9 @@ enum cef_media_route_create_result_t
     CEF_MRCR_NO_SUPPORTED_PROVIDER = 7,
     CEF_MRCR_CANCELLED = 8,
     CEF_MRCR_ROUTE_ALREADY_EXISTS = 9,
+    CEF_MRCR_ROUTE_ALREADY_TERMINATED = 11,
 
-    CEF_MRCR_TOTAL_COUNT = 11 // The total number of values.
+    CEF_MRCR_TOTAL_COUNT = 12 // The total number of values.
 }
 
 ///
@@ -18181,14 +5080,14 @@ enum cef_media_sink_icon_type_t
 ///
 // Device information for a MediaSink object.
 ///
-struct _cef_media_sink_device_info_t
+struct cef_media_sink_device_info_t
 {
     cef_string_t ip_address;
     int port;
     cef_string_t model_name;
 }
 
-alias cef_media_sink_device_info_t = _cef_media_sink_device_info_t;
+
 
 ///
 // Represents commands available to TextField.
@@ -18203,9 +5102,41 @@ enum cef_text_field_commands_t
     CEF_TFC_SELECT_ALL = 6
 }
 
-// CEF_INCLUDE_INTERNAL_CEF_TYPES_H_
+///
+// Supported Chrome toolbar types.
+///
+enum cef_chrome_toolbar_type_t
+{
+    CEF_CTT_NONE = 1,
+    CEF_CTT_NORMAL = 2,
+    CEF_CTT_LOCATION = 3
+}
 
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
+///
+// Docking modes supported by CefWindow::AddOverlay.
+///
+enum cef_docking_mode_t
+{
+    CEF_DOCKING_MODE_TOP_LEFT = 1,
+    CEF_DOCKING_MODE_TOP_RIGHT = 2,
+    CEF_DOCKING_MODE_BOTTOM_LEFT = 3,
+    CEF_DOCKING_MODE_BOTTOM_RIGHT = 4,
+    CEF_DOCKING_MODE_CUSTOM = 5
+}
+
+///
+// Show states supported by CefWindowDelegate::GetInitialShowState.
+///
+enum cef_show_state_t
+{
+    CEF_SHOW_STATE_NORMAL = 1,
+    CEF_SHOW_STATE_MINIMIZED = 2,
+    CEF_SHOW_STATE_MAXIMIZED = 3,
+    CEF_SHOW_STATE_FULLSCREEN = 4
+}
+
+// CEF_INCLUDE_INTERNAL_CEF_TYPES_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -18240,15 +5171,8550 @@ enum cef_text_field_commands_t
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=7ce0953f069204a4dd2037c4a05ac9454c5e66a6$
+// $hash=c487e5fd787b1be8224a8981839e0cfdd0ed74f3$
 //
 
 extern (C):
 
+///
+// Implement this structure to receive accessibility notification when
+// accessibility events have been registered. The functions of this structure
+// will be called on the UI thread.
+///
+struct cef_accessibility_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called after renderer process sends accessibility tree changes to the
+    // browser process.
+    ///
+    extern(System) void function (
+        cef_accessibility_handler_t* self,
+        cef_value_t* value) nothrow on_accessibility_tree_change;
+
+    ///
+    // Called after renderer process sends accessibility location changes to the
+    // browser process.
+    ///
+    extern(System) void function (
+        cef_accessibility_handler_t* self,
+        cef_value_t* value) nothrow on_accessibility_location_change;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_ACCESSIBILITY_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=a4b63e6e7942e3a3961b4f7141a963980178ae6f$
+//
+
+extern (C):
+
+///
+// Implement this structure to provide handler implementations. Methods will be
+// called by the process and/or thread indicated.
+///
+struct cef_app_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Provides an opportunity to view and/or modify command-line arguments before
+    // processing by CEF and Chromium. The |process_type| value will be NULL for
+    // the browser process. Do not keep a reference to the cef_command_line_t
+    // object passed to this function. The CefSettings.command_line_args_disabled
+    // value can be used to start with an NULL command-line object. Any values
+    // specified in CefSettings that equate to command-line arguments will be set
+    // before this function is called. Be cautious when using this function to
+    // modify command-line arguments for non-browser processes as this may result
+    // in undefined behavior including crashes.
+    ///
+    extern(System) void function (
+        cef_app_t* self,
+        const(cef_string_t)* process_type,
+        cef_command_line_t* command_line) nothrow on_before_command_line_processing;
+
+    ///
+    // Provides an opportunity to register custom schemes. Do not keep a reference
+    // to the |registrar| object. This function is called on the main thread for
+    // each process and the registered schemes should be the same across all
+    // processes.
+    ///
+    extern(System) void function (
+        cef_app_t* self,
+        cef_scheme_registrar_t* registrar) nothrow on_register_custom_schemes;
+
+    ///
+    // Return the handler for resource bundle events. If
+    // CefSettings.pack_loading_disabled is true (1) a handler must be returned.
+    // If no handler is returned resources will be loaded from pack files. This
+    // function is called by the browser and render processes on multiple threads.
+    ///
+    extern(System) cef_resource_bundle_handler_t* function (
+        cef_app_t* self) nothrow get_resource_bundle_handler;
+
+    ///
+    // Return the handler for functionality specific to the browser process. This
+    // function is called on multiple threads in the browser process.
+    ///
+    extern(System) cef_browser_process_handler_t* function (
+        cef_app_t* self) nothrow get_browser_process_handler;
+
+    ///
+    // Return the handler for functionality specific to the render process. This
+    // function is called on the render process main thread.
+    ///
+    extern(System) cef_render_process_handler_t* function (
+        cef_app_t* self) nothrow get_render_process_handler;
+}
+
+
+
+///
+// This function should be called from the application entry point function to
+// execute a secondary process. It can be used to run secondary processes from
+// the browser client executable (default behavior) or from a separate
+// executable specified by the CefSettings.browser_subprocess_path value. If
+// called for the browser process (identified by no "type" command-line value)
+// it will return immediately with a value of -1. If called for a recognized
+// secondary process it will block until the process should exit and then return
+// the process exit code. The |application| parameter may be NULL. The
+// |windows_sandbox_info| parameter is only used on Windows and may be NULL (see
+// cef_sandbox_win.h for details).
+///
+int cef_execute_process (
+    const(cef_main_args_t)* args,
+    cef_app_t* application,
+    void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to initialize
+// the CEF browser process. The |application| parameter may be NULL. A return
+// value of true (1) indicates that it succeeded and false (0) indicates that it
+// failed. The |windows_sandbox_info| parameter is only used on Windows and may
+// be NULL (see cef_sandbox_win.h for details).
+///
+int cef_initialize (
+    const(cef_main_args_t)* args,
+    const(cef_settings_t)* settings,
+    cef_app_t* application,
+    void* windows_sandbox_info);
+
+///
+// This function should be called on the main application thread to shut down
+// the CEF browser process before the application exits.
+///
+void cef_shutdown ();
+
+///
+// Perform a single iteration of CEF message loop processing. This function is
+// provided for cases where the CEF message loop must be integrated into an
+// existing application message loop. Use of this function is not recommended
+// for most users; use either the cef_run_message_loop() function or
+// CefSettings.multi_threaded_message_loop if possible. When using this function
+// care must be taken to balance performance against excessive CPU usage. It is
+// recommended to enable the CefSettings.external_message_pump option when using
+// this function so that
+// cef_browser_process_handler_t::on_schedule_message_pump_work() callbacks can
+// facilitate the scheduling process. This function should only be called on the
+// main application thread and only if cef_initialize() is called with a
+// CefSettings.multi_threaded_message_loop value of false (0). This function
+// will not block.
+///
+void cef_do_message_loop_work ();
+
+///
+// Run the CEF message loop. Use this function instead of an application-
+// provided message loop to get the best balance between performance and CPU
+// usage. This function should only be called on the main application thread and
+// only if cef_initialize() is called with a
+// CefSettings.multi_threaded_message_loop value of false (0). This function
+// will block until a quit message is received by the system.
+///
+void cef_run_message_loop ();
+
+///
+// Quit the CEF message loop that was started by calling cef_run_message_loop().
+// This function should only be called on the main application thread and only
+// if cef_run_message_loop() was used.
+///
+void cef_quit_message_loop ();
+
+///
+// Set to true (1) before calling Windows APIs like TrackPopupMenu that enter a
+// modal message loop. Set to false (0) after exiting the modal message loop.
+///
+void cef_set_osmodal_loop (int osModalLoop);
+
+///
+// Call during process startup to enable High-DPI support on Windows 7 or newer.
+// Older versions of Windows should be left DPI-unaware because they do not
+// support DirectWrite and GDI fonts are kerned very badly.
+///
+void cef_enable_highdpi_support ();
+
+// CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=7a483ed552ecca4f1aaa03800d366beca1ea2dee$
+//
+
+extern (C):
+
+///
+// Implement this structure to handle audio events.
+///
+struct cef_audio_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called on the UI thread to allow configuration of audio stream parameters.
+    // Return true (1) to proceed with audio stream capture, or false (0) to
+    // cancel it. All members of |params| can optionally be configured here, but
+    // they are also pre-filled with some sensible defaults.
+    ///
+    extern(System) int function (
+        cef_audio_handler_t* self,
+        cef_browser_t* browser,
+        cef_audio_parameters_t* params) nothrow get_audio_parameters;
+
+    ///
+    // Called on a browser audio capture thread when the browser starts streaming
+    // audio. OnAudioSteamStopped will always be called after
+    // OnAudioStreamStarted; both functions may be called multiple times for the
+    // same browser. |params| contains the audio parameters like sample rate and
+    // channel layout. |channels| is the number of channels.
+    ///
+    extern(System) void function (
+        cef_audio_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_audio_parameters_t)* params,
+        int channels) nothrow on_audio_stream_started;
+
+    ///
+    // Called on the audio stream thread when a PCM packet is received for the
+    // stream. |data| is an array representing the raw PCM data as a floating
+    // point type, i.e. 4-byte value(s). |frames| is the number of frames in the
+    // PCM packet. |pts| is the presentation timestamp (in milliseconds since the
+    // Unix Epoch) and represents the time at which the decompressed packet should
+    // be presented to the user. Based on |frames| and the |channel_layout| value
+    // passed to OnAudioStreamStarted you can calculate the size of the |data|
+    // array in bytes.
+    ///
+    extern(System) void function (
+        cef_audio_handler_t* self,
+        cef_browser_t* browser,
+        const(float*)* data,
+        int frames,
+        int64 pts) nothrow on_audio_stream_packet;
+
+    ///
+    // Called on the UI thread when the stream has stopped. OnAudioSteamStopped
+    // will always be called after OnAudioStreamStarted; both functions may be
+    // called multiple times for the same stream.
+    ///
+    extern(System) void function (
+        cef_audio_handler_t* self,
+        cef_browser_t* browser) nothrow on_audio_stream_stopped;
+
+    ///
+    // Called on the UI or audio stream thread when an error occurred. During the
+    // stream creation phase this callback will be called on the UI thread while
+    // in the capturing phase it will be called on the audio stream thread. The
+    // stream will be stopped immediately.
+    ///
+    extern(System) void function (
+        cef_audio_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* message) nothrow on_audio_stream_error;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_AUDIO_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=2b9508a328ed0218e2c576af455f8d76e5978545$
+//
+
+extern (C):
+
+///
+// Callback structure used for asynchronous continuation of authentication
+// requests.
+///
+struct cef_auth_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Continue the authentication request.
+    ///
+    extern(System) void function (
+        cef_auth_callback_t* self,
+        const(cef_string_t)* username,
+        const(cef_string_t)* password) nothrow cont;
+
+    ///
+    // Cancel the authentication request.
+    ///
+    extern(System) void function (cef_auth_callback_t* self) nothrow cancel;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_AUTH_CALLBACK_CAPI_H_
+// Copyright (c) 2014 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+extern (C):
+
+///
+// All ref-counted framework structures must include this structure first.
+///
+struct cef_base_ref_counted_t
+{
+    ///
+    // Size of the data structure.
+    ///
+    size_t size;
+
+    ///
+    // Called to increment the reference count for the object. Should be called
+    // for every new copy of a pointer to a given object.
+    ///
+    extern(System) void function (cef_base_ref_counted_t* self) nothrow add_ref;
+
+    ///
+    // Called to decrement the reference count for the object. If the reference
+    // count falls to 0 the object should self-delete. Returns true (1) if the
+    // resulting reference count is 0.
+    ///
+    extern(System) int function (cef_base_ref_counted_t* self) nothrow release;
+
+    ///
+    // Returns true (1) if the current reference count is 1.
+    ///
+    extern(System) int function (cef_base_ref_counted_t* self) nothrow has_one_ref;
+
+    ///
+    // Returns true (1) if the current reference count is at least 1.
+    ///
+    extern(System) int function (cef_base_ref_counted_t* self) nothrow has_at_least_one_ref;
+}
+
+
+
+///
+// All scoped framework structures must include this structure first.
+///
+struct cef_base_scoped_t
+{
+    ///
+    // Size of the data structure.
+    ///
+    size_t size;
+
+    ///
+    // Called to delete this object. May be NULL if the object is not owned.
+    ///
+    extern(System) void function (cef_base_scoped_t* self) nothrow del;
+}
+
+
+
+// Check that the structure |s|, which is defined with a size_t member at the
+// top, is large enough to contain the specified member |f|.
+
+
+
+
+// CEF_INCLUDE_CAPI_CEF_BASE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=b83b96e2b90124bba8084e2df7f66cc6749df872$
+//
+
+import core.stdc.config;
+
+extern (C):
+
+
+
+///
+// Structure used to represent a browser. When used in the browser process the
+// functions of this structure may be called on any thread unless otherwise
+// indicated in the comments. When used in the render process the functions of
+// this structure may only be called on the main thread.
+///
+struct cef_browser_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // True if this object is currently valid. This will return false (0) after
+    // cef_life_span_handler_t::OnBeforeClose is called.
+    ///
+    extern(System) int function (cef_browser_t* self) nothrow is_valid;
+
+    ///
+    // Returns the browser host object. This function can only be called in the
+    // browser process.
+    ///
+    extern(System) cef_browser_host_t* function (cef_browser_t* self) nothrow get_host;
+
+    ///
+    // Returns true (1) if the browser can navigate backwards.
+    ///
+    extern(System) int function (cef_browser_t* self) nothrow can_go_back;
+
+    ///
+    // Navigate backwards.
+    ///
+    extern(System) void function (cef_browser_t* self) nothrow go_back;
+
+    ///
+    // Returns true (1) if the browser can navigate forwards.
+    ///
+    extern(System) int function (cef_browser_t* self) nothrow can_go_forward;
+
+    ///
+    // Navigate forwards.
+    ///
+    extern(System) void function (cef_browser_t* self) nothrow go_forward;
+
+    ///
+    // Returns true (1) if the browser is currently loading.
+    ///
+    extern(System) int function (cef_browser_t* self) nothrow is_loading;
+
+    ///
+    // Reload the current page.
+    ///
+    extern(System) void function (cef_browser_t* self) nothrow reload;
+
+    ///
+    // Reload the current page ignoring any cached data.
+    ///
+    extern(System) void function (cef_browser_t* self) nothrow reload_ignore_cache;
+
+    ///
+    // Stop loading the page.
+    ///
+    extern(System) void function (cef_browser_t* self) nothrow stop_load;
+
+    ///
+    // Returns the globally unique identifier for this browser. This value is also
+    // used as the tabId for extension APIs.
+    ///
+    extern(System) int function (cef_browser_t* self) nothrow get_identifier;
+
+    ///
+    // Returns true (1) if this object is pointing to the same handle as |that|
+    // object.
+    ///
+    extern(System) int function (cef_browser_t* self, cef_browser_t* that) nothrow is_same;
+
+    ///
+    // Returns true (1) if the browser is a popup.
+    ///
+    extern(System) int function (cef_browser_t* self) nothrow is_popup;
+
+    ///
+    // Returns true (1) if a document has been loaded in the browser.
+    ///
+    extern(System) int function (cef_browser_t* self) nothrow has_document;
+
+    ///
+    // Returns the main (top-level) frame for the browser. In the browser process
+    // this will return a valid object until after
+    // cef_life_span_handler_t::OnBeforeClose is called. In the renderer process
+    // this will return NULL if the main frame is hosted in a different renderer
+    // process (e.g. for cross-origin sub-frames). The main frame object will
+    // change during cross-origin navigation or re-navigation after renderer
+    // process termination (due to crashes, etc).
+    ///
+    extern(System) cef_frame_t* function (cef_browser_t* self) nothrow get_main_frame;
+
+    ///
+    // Returns the focused frame for the browser.
+    ///
+    extern(System) cef_frame_t* function (cef_browser_t* self) nothrow get_focused_frame;
+
+    ///
+    // Returns the frame with the specified identifier, or NULL if not found.
+    ///
+    extern(System) cef_frame_t* function (
+        cef_browser_t* self,
+        int64 identifier) nothrow get_frame_byident;
+
+    ///
+    // Returns the frame with the specified name, or NULL if not found.
+    ///
+    extern(System) cef_frame_t* function (
+        cef_browser_t* self,
+        const(cef_string_t)* name) nothrow get_frame;
+
+    ///
+    // Returns the number of frames that currently exist.
+    ///
+    extern(System) size_t function (cef_browser_t* self) nothrow get_frame_count;
+
+    ///
+    // Returns the identifiers of all existing frames.
+    ///
+    extern(System) void function (
+        cef_browser_t* self,
+        size_t* identifiersCount,
+        int64* identifiers) nothrow get_frame_identifiers;
+
+    ///
+    // Returns the names of all existing frames.
+    ///
+    extern(System) void function (
+        cef_browser_t* self,
+        cef_string_list_t names) nothrow get_frame_names;
+}
+
+
+
+///
+// Callback structure for cef_browser_host_t::RunFileDialog. The functions of
+// this structure will be called on the browser process UI thread.
+///
+struct cef_run_file_dialog_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called asynchronously after the file dialog is dismissed.
+    // |selected_accept_filter| is the 0-based index of the value selected from
+    // the accept filters array passed to cef_browser_host_t::RunFileDialog.
+    // |file_paths| will be a single value or a list of values depending on the
+    // dialog mode. If the selection was cancelled |file_paths| will be NULL.
+    ///
+    extern(System) void function (
+        cef_run_file_dialog_callback_t* self,
+        int selected_accept_filter,
+        cef_string_list_t file_paths) nothrow on_file_dialog_dismissed;
+}
+
+
+
+///
+// Callback structure for cef_browser_host_t::GetNavigationEntries. The
+// functions of this structure will be called on the browser process UI thread.
+///
+struct cef_navigation_entry_visitor_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be executed. Do not keep a reference to |entry| outside of
+    // this callback. Return true (1) to continue visiting entries or false (0) to
+    // stop. |current| is true (1) if this entry is the currently loaded
+    // navigation entry. |index| is the 0-based index of this entry and |total| is
+    // the total number of entries.
+    ///
+    extern(System) int function (
+        cef_navigation_entry_visitor_t* self,
+        cef_navigation_entry_t* entry,
+        int current,
+        int index,
+        int total) nothrow visit;
+}
+
+
+
+///
+// Callback structure for cef_browser_host_t::PrintToPDF. The functions of this
+// structure will be called on the browser process UI thread.
+///
+struct cef_pdf_print_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be executed when the PDF printing has completed. |path| is
+    // the output path. |ok| will be true (1) if the printing completed
+    // successfully or false (0) otherwise.
+    ///
+    extern(System) void function (
+        cef_pdf_print_callback_t* self,
+        const(cef_string_t)* path,
+        int ok) nothrow on_pdf_print_finished;
+}
+
+
+
+///
+// Callback structure for cef_browser_host_t::DownloadImage. The functions of
+// this structure will be called on the browser process UI thread.
+///
+struct cef_download_image_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be executed when the image download has completed.
+    // |image_url| is the URL that was downloaded and |http_status_code| is the
+    // resulting HTTP status code. |image| is the resulting image, possibly at
+    // multiple scale factors, or NULL if the download failed.
+    ///
+    extern(System) void function (
+        cef_download_image_callback_t* self,
+        const(cef_string_t)* image_url,
+        int http_status_code,
+        cef_image_t* image) nothrow on_download_image_finished;
+}
+
+
+
+///
+// Structure used to represent the browser process aspects of a browser. The
+// functions of this structure can only be called in the browser process. They
+// may be called on any thread in that process unless otherwise indicated in the
+// comments.
+///
+struct cef_browser_host_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the hosted browser object.
+    ///
+    extern(System) cef_browser_t* function (cef_browser_host_t* self) nothrow get_browser;
+
+    ///
+    // Request that the browser close. The JavaScript 'onbeforeunload' event will
+    // be fired. If |force_close| is false (0) the event handler, if any, will be
+    // allowed to prompt the user and the user can optionally cancel the close. If
+    // |force_close| is true (1) the prompt will not be displayed and the close
+    // will proceed. Results in a call to cef_life_span_handler_t::do_close() if
+    // the event handler allows the close or if |force_close| is true (1). See
+    // cef_life_span_handler_t::do_close() documentation for additional usage
+    // information.
+    ///
+    extern(System) void function (cef_browser_host_t* self, int force_close) nothrow close_browser;
+
+    ///
+    // Helper for closing a browser. Call this function from the top-level window
+    // close handler (if any). Internally this calls CloseBrowser(false (0)) if
+    // the close has not yet been initiated. This function returns false (0) while
+    // the close is pending and true (1) after the close has completed. See
+    // close_browser() and cef_life_span_handler_t::do_close() documentation for
+    // additional usage information. This function must be called on the browser
+    // process UI thread.
+    ///
+    extern(System) int function (cef_browser_host_t* self) nothrow try_close_browser;
+
+    ///
+    // Set whether the browser is focused.
+    ///
+    extern(System) void function (cef_browser_host_t* self, int focus) nothrow set_focus;
+
+    ///
+    // Retrieve the window handle (if any) for this browser. If this browser is
+    // wrapped in a cef_browser_view_t this function should be called on the
+    // browser process UI thread and it will return the handle for the top-level
+    // native window.
+    ///
+    extern(System) c_ulong function (cef_browser_host_t* self) nothrow get_window_handle;
+
+    ///
+    // Retrieve the window handle (if any) of the browser that opened this
+    // browser. Will return NULL for non-popup browsers or if this browser is
+    // wrapped in a cef_browser_view_t. This function can be used in combination
+    // with custom handling of modal windows.
+    ///
+    extern(System) c_ulong function (cef_browser_host_t* self) nothrow get_opener_window_handle;
+
+    ///
+    // Returns true (1) if this browser is wrapped in a cef_browser_view_t.
+    ///
+    extern(System) int function (cef_browser_host_t* self) nothrow has_view;
+
+    ///
+    // Returns the client for this browser.
+    ///
+    extern(System) cef_client_t* function (cef_browser_host_t* self) nothrow get_client;
+
+    ///
+    // Returns the request context for this browser.
+    ///
+    extern(System) cef_request_context_t* function (
+        cef_browser_host_t* self) nothrow get_request_context;
+
+    ///
+    // Get the current zoom level. The default zoom level is 0.0. This function
+    // can only be called on the UI thread.
+    ///
+    extern(System) double function (cef_browser_host_t* self) nothrow get_zoom_level;
+
+    ///
+    // Change the zoom level to the specified value. Specify 0.0 to reset the zoom
+    // level. If called on the UI thread the change will be applied immediately.
+    // Otherwise, the change will be applied asynchronously on the UI thread.
+    ///
+    extern(System) void function (cef_browser_host_t* self, double zoomLevel) nothrow set_zoom_level;
+
+    ///
+    // Call to run a file chooser dialog. Only a single file chooser dialog may be
+    // pending at any given time. |mode| represents the type of dialog to display.
+    // |title| to the title to be used for the dialog and may be NULL to show the
+    // default title ("Open" or "Save" depending on the mode). |default_file_path|
+    // is the path with optional directory and/or file name component that will be
+    // initially selected in the dialog. |accept_filters| are used to restrict the
+    // selectable file types and may any combination of (a) valid lower-cased MIME
+    // types (e.g. "text/*" or "image/*"), (b) individual file extensions (e.g.
+    // ".txt" or ".png"), or (c) combined description and file extension delimited
+    // using "|" and ";" (e.g. "Image Types|.png;.gif;.jpg").
+    // |selected_accept_filter| is the 0-based index of the filter that will be
+    // selected by default. |callback| will be executed after the dialog is
+    // dismissed or immediately if another dialog is already pending. The dialog
+    // will be initiated asynchronously on the UI thread.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        cef_file_dialog_mode_t mode,
+        const(cef_string_t)* title,
+        const(cef_string_t)* default_file_path,
+        cef_string_list_t accept_filters,
+        int selected_accept_filter,
+        cef_run_file_dialog_callback_t* callback) nothrow run_file_dialog;
+
+    ///
+    // Download the file at |url| using cef_download_handler_t.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_string_t)* url) nothrow start_download;
+
+    ///
+    // Download |image_url| and execute |callback| on completion with the images
+    // received from the renderer. If |is_favicon| is true (1) then cookies are
+    // not sent and not accepted during download. Images with density independent
+    // pixel (DIP) sizes larger than |max_image_size| are filtered out from the
+    // image results. Versions of the image at different scale factors may be
+    // downloaded up to the maximum scale factor supported by the system. If there
+    // are no image results <= |max_image_size| then the smallest image is resized
+    // to |max_image_size| and is the only result. A |max_image_size| of 0 means
+    // unlimited. If |bypass_cache| is true (1) then |image_url| is requested from
+    // the server even if it is present in the browser cache.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_string_t)* image_url,
+        int is_favicon,
+        uint32 max_image_size,
+        int bypass_cache,
+        cef_download_image_callback_t* callback) nothrow download_image;
+
+    ///
+    // Print the current browser contents.
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow print;
+
+    ///
+    // Print the current browser contents to the PDF file specified by |path| and
+    // execute |callback| on completion. The caller is responsible for deleting
+    // |path| when done. For PDF printing to work on Linux you must implement the
+    // cef_print_handler_t::GetPdfPaperSize function.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_string_t)* path,
+        const(cef_pdf_print_settings_t)* settings,
+        cef_pdf_print_callback_t* callback) nothrow print_to_pdf;
+
+    ///
+    // Search for |searchText|. |identifier| must be a unique ID and these IDs
+    // must strictly increase so that newer requests always have greater IDs than
+    // older requests. If |identifier| is zero or less than the previous ID value
+    // then it will be automatically assigned a new valid ID. |forward| indicates
+    // whether to search forward or backward within the page. |matchCase|
+    // indicates whether the search should be case-sensitive. |findNext| indicates
+    // whether this is the first request or a follow-up. The cef_find_handler_t
+    // instance, if any, returned via cef_client_t::GetFindHandler will be called
+    // to report find results.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        int identifier,
+        const(cef_string_t)* searchText,
+        int forward,
+        int matchCase,
+        int findNext) nothrow find;
+
+    ///
+    // Cancel all searches that are currently going on.
+    ///
+    extern(System) void function (cef_browser_host_t* self, int clearSelection) nothrow stop_finding;
+
+    ///
+    // Open developer tools (DevTools) in its own browser. The DevTools browser
+    // will remain associated with this browser. If the DevTools browser is
+    // already open then it will be focused, in which case the |windowInfo|,
+    // |client| and |settings| parameters will be ignored. If |inspect_element_at|
+    // is non-NULL then the element at the specified (x,y) location will be
+    // inspected. The |windowInfo| parameter will be ignored if this browser is
+    // wrapped in a cef_browser_view_t.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_window_info_t)* windowInfo,
+        cef_client_t* client,
+        const(cef_browser_settings_t)* settings,
+        const(cef_point_t)* inspect_element_at) nothrow show_dev_tools;
+
+    ///
+    // Explicitly close the associated DevTools browser, if any.
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow close_dev_tools;
+
+    ///
+    // Returns true (1) if this browser currently has an associated DevTools
+    // browser. Must be called on the browser process UI thread.
+    ///
+    extern(System) int function (cef_browser_host_t* self) nothrow has_dev_tools;
+
+    ///
+    // Send a function call message over the DevTools protocol. |message| must be
+    // a UTF8-encoded JSON dictionary that contains "id" (int), "function"
+    // (string) and "params" (dictionary, optional) values. See the DevTools
+    // protocol documentation at https://chromedevtools.github.io/devtools-
+    // protocol/ for details of supported functions and the expected "params"
+    // dictionary contents. |message| will be copied if necessary. This function
+    // will return true (1) if called on the UI thread and the message was
+    // successfully submitted for validation, otherwise false (0). Validation will
+    // be applied asynchronously and any messages that fail due to formatting
+    // errors or missing parameters may be discarded without notification. Prefer
+    // ExecuteDevToolsMethod if a more structured approach to message formatting
+    // is desired.
+    //
+    // Every valid function call will result in an asynchronous function result or
+    // error message that references the sent message "id". Event messages are
+    // received while notifications are enabled (for example, between function
+    // calls for "Page.enable" and "Page.disable"). All received messages will be
+    // delivered to the observer(s) registered with AddDevToolsMessageObserver.
+    // See cef_dev_tools_message_observer_t::OnDevToolsMessage documentation for
+    // details of received message contents.
+    //
+    // Usage of the SendDevToolsMessage, ExecuteDevToolsMethod and
+    // AddDevToolsMessageObserver functions does not require an active DevTools
+    // front-end or remote-debugging session. Other active DevTools sessions will
+    // continue to function independently. However, any modification of global
+    // browser state by one session may not be reflected in the UI of other
+    // sessions.
+    //
+    // Communication with the DevTools front-end (when displayed) can be logged
+    // for development purposes by passing the `--devtools-protocol-log-
+    // file=<path>` command-line flag.
+    ///
+    extern(System) int function (
+        cef_browser_host_t* self,
+        const(void)* message,
+        size_t message_size) nothrow send_dev_tools_message;
+
+    ///
+    // Execute a function call over the DevTools protocol. This is a more
+    // structured version of SendDevToolsMessage. |message_id| is an incremental
+    // number that uniquely identifies the message (pass 0 to have the next number
+    // assigned automatically based on previous values). |function| is the
+    // function name. |params| are the function parameters, which may be NULL. See
+    // the DevTools protocol documentation (linked above) for details of supported
+    // functions and the expected |params| dictionary contents. This function will
+    // return the assigned message ID if called on the UI thread and the message
+    // was successfully submitted for validation, otherwise 0. See the
+    // SendDevToolsMessage documentation for additional usage information.
+    ///
+    extern(System) int function (
+        cef_browser_host_t* self,
+        int message_id,
+        const(cef_string_t)* method,
+        cef_dictionary_value_t* params) nothrow execute_dev_tools_method;
+
+    ///
+    // Add an observer for DevTools protocol messages (function results and
+    // events). The observer will remain registered until the returned
+    // Registration object is destroyed. See the SendDevToolsMessage documentation
+    // for additional usage information.
+    ///
+    extern(System) cef_registration_t* function (
+        cef_browser_host_t* self,
+        cef_dev_tools_message_observer_t* observer) nothrow add_dev_tools_message_observer;
+
+    ///
+    // Retrieve a snapshot of current navigation entries as values sent to the
+    // specified visitor. If |current_only| is true (1) only the current
+    // navigation entry will be sent, otherwise all navigation entries will be
+    // sent.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        cef_navigation_entry_visitor_t* visitor,
+        int current_only) nothrow get_navigation_entries;
+
+    ///
+    // If a misspelled word is currently selected in an editable node calling this
+    // function will replace it with the specified |word|.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_string_t)* word) nothrow replace_misspelling;
+
+    ///
+    // Add the specified |word| to the spelling dictionary.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_string_t)* word) nothrow add_word_to_dictionary;
+
+    ///
+    // Returns true (1) if window rendering is disabled.
+    ///
+    extern(System) int function (cef_browser_host_t* self) nothrow is_window_rendering_disabled;
+
+    ///
+    // Notify the browser that the widget has been resized. The browser will first
+    // call cef_render_handler_t::GetViewRect to get the new size and then call
+    // cef_render_handler_t::OnPaint asynchronously with the updated regions. This
+    // function is only used when window rendering is disabled.
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow was_resized;
+
+    ///
+    // Notify the browser that it has been hidden or shown. Layouting and
+    // cef_render_handler_t::OnPaint notification will stop when the browser is
+    // hidden. This function is only used when window rendering is disabled.
+    ///
+    extern(System) void function (cef_browser_host_t* self, int hidden) nothrow was_hidden;
+
+    ///
+    // Send a notification to the browser that the screen info has changed. The
+    // browser will then call cef_render_handler_t::GetScreenInfo to update the
+    // screen information with the new values. This simulates moving the webview
+    // window from one display to another, or changing the properties of the
+    // current display. This function is only used when window rendering is
+    // disabled.
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow notify_screen_info_changed;
+
+    ///
+    // Invalidate the view. The browser will call cef_render_handler_t::OnPaint
+    // asynchronously. This function is only used when window rendering is
+    // disabled.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        cef_paint_element_type_t type) nothrow invalidate;
+
+    ///
+    // Issue a BeginFrame request to Chromium.  Only valid when
+    // cef_window_tInfo::external_begin_frame_enabled is set to true (1).
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow send_external_begin_frame;
+
+    ///
+    // Send a key event to the browser.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_key_event_t)* event) nothrow send_key_event;
+
+    ///
+    // Send a mouse click event to the browser. The |x| and |y| coordinates are
+    // relative to the upper-left corner of the view.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_mouse_event_t)* event,
+        cef_mouse_button_type_t type,
+        int mouseUp,
+        int clickCount) nothrow send_mouse_click_event;
+
+    ///
+    // Send a mouse move event to the browser. The |x| and |y| coordinates are
+    // relative to the upper-left corner of the view.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_mouse_event_t)* event,
+        int mouseLeave) nothrow send_mouse_move_event;
+
+    ///
+    // Send a mouse wheel event to the browser. The |x| and |y| coordinates are
+    // relative to the upper-left corner of the view. The |deltaX| and |deltaY|
+    // values represent the movement delta in the X and Y directions respectively.
+    // In order to scroll inside select popups with window rendering disabled
+    // cef_render_handler_t::GetScreenPoint should be implemented properly.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_mouse_event_t)* event,
+        int deltaX,
+        int deltaY) nothrow send_mouse_wheel_event;
+
+    ///
+    // Send a touch event to the browser for a windowless browser.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_touch_event_t)* event) nothrow send_touch_event;
+
+    ///
+    // Send a capture lost event to the browser.
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow send_capture_lost_event;
+
+    ///
+    // Notify the browser that the window hosting it is about to be moved or
+    // resized. This function is only used on Windows and Linux.
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow notify_move_or_resize_started;
+
+    ///
+    // Returns the maximum rate in frames per second (fps) that
+    // cef_render_handler_t:: OnPaint will be called for a windowless browser. The
+    // actual fps may be lower if the browser cannot generate frames at the
+    // requested rate. The minimum value is 1 and the maximum value is 60 (default
+    // 30). This function can only be called on the UI thread.
+    ///
+    extern(System) int function (cef_browser_host_t* self) nothrow get_windowless_frame_rate;
+
+    ///
+    // Set the maximum rate in frames per second (fps) that cef_render_handler_t::
+    // OnPaint will be called for a windowless browser. The actual fps may be
+    // lower if the browser cannot generate frames at the requested rate. The
+    // minimum value is 1 and the maximum value is 60 (default 30). Can also be
+    // set at browser creation via cef_browser_tSettings.windowless_frame_rate.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        int frame_rate) nothrow set_windowless_frame_rate;
+
+    ///
+    // Begins a new composition or updates the existing composition. Blink has a
+    // special node (a composition node) that allows the input function to change
+    // text without affecting other DOM nodes. |text| is the optional text that
+    // will be inserted into the composition node. |underlines| is an optional set
+    // of ranges that will be underlined in the resulting text.
+    // |replacement_range| is an optional range of the existing text that will be
+    // replaced. |selection_range| is an optional range of the resulting text that
+    // will be selected after insertion or replacement. The |replacement_range|
+    // value is only used on OS X.
+    //
+    // This function may be called multiple times as the composition changes. When
+    // the client is done making changes the composition should either be canceled
+    // or completed. To cancel the composition call ImeCancelComposition. To
+    // complete the composition call either ImeCommitText or
+    // ImeFinishComposingText. Completion is usually signaled when:
+    //   A. The client receives a WM_IME_COMPOSITION message with a GCS_RESULTSTR
+    //      flag (on Windows), or;
+    //   B. The client receives a "commit" signal of GtkIMContext (on Linux), or;
+    //   C. insertText of NSTextInput is called (on Mac).
+    //
+    // This function is only used when window rendering is disabled.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_string_t)* text,
+        size_t underlinesCount,
+        const(cef_composition_underline_t)* underlines,
+        const(cef_range_t)* replacement_range,
+        const(cef_range_t)* selection_range) nothrow ime_set_composition;
+
+    ///
+    // Completes the existing composition by optionally inserting the specified
+    // |text| into the composition node. |replacement_range| is an optional range
+    // of the existing text that will be replaced. |relative_cursor_pos| is where
+    // the cursor will be positioned relative to the current cursor position. See
+    // comments on ImeSetComposition for usage. The |replacement_range| and
+    // |relative_cursor_pos| values are only used on OS X. This function is only
+    // used when window rendering is disabled.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_string_t)* text,
+        const(cef_range_t)* replacement_range,
+        int relative_cursor_pos) nothrow ime_commit_text;
+
+    ///
+    // Completes the existing composition by applying the current composition node
+    // contents. If |keep_selection| is false (0) the current selection, if any,
+    // will be discarded. See comments on ImeSetComposition for usage. This
+    // function is only used when window rendering is disabled.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        int keep_selection) nothrow ime_finish_composing_text;
+
+    ///
+    // Cancels the existing composition and discards the composition node contents
+    // without applying them. See comments on ImeSetComposition for usage. This
+    // function is only used when window rendering is disabled.
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow ime_cancel_composition;
+
+    ///
+    // Call this function when the user drags the mouse into the web view (before
+    // calling DragTargetDragOver/DragTargetLeave/DragTargetDrop). |drag_data|
+    // should not contain file contents as this type of data is not allowed to be
+    // dragged into the web view. File contents can be removed using
+    // cef_drag_data_t::ResetFileContents (for example, if |drag_data| comes from
+    // cef_render_handler_t::StartDragging). This function is only used when
+    // window rendering is disabled.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        cef_drag_data_t* drag_data,
+        const(cef_mouse_event_t)* event,
+        cef_drag_operations_mask_t allowed_ops) nothrow drag_target_drag_enter;
+
+    ///
+    // Call this function each time the mouse is moved across the web view during
+    // a drag operation (after calling DragTargetDragEnter and before calling
+    // DragTargetDragLeave/DragTargetDrop). This function is only used when window
+    // rendering is disabled.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_mouse_event_t)* event,
+        cef_drag_operations_mask_t allowed_ops) nothrow drag_target_drag_over;
+
+    ///
+    // Call this function when the user drags the mouse out of the web view (after
+    // calling DragTargetDragEnter). This function is only used when window
+    // rendering is disabled.
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow drag_target_drag_leave;
+
+    ///
+    // Call this function when the user completes the drag operation by dropping
+    // the object onto the web view (after calling DragTargetDragEnter). The
+    // object being dropped is |drag_data|, given as an argument to the previous
+    // DragTargetDragEnter call. This function is only used when window rendering
+    // is disabled.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        const(cef_mouse_event_t)* event) nothrow drag_target_drop;
+
+    ///
+    // Call this function when the drag operation started by a
+    // cef_render_handler_t::StartDragging call has ended either in a drop or by
+    // being cancelled. |x| and |y| are mouse coordinates relative to the upper-
+    // left corner of the view. If the web view is both the drag source and the
+    // drag target then all DragTarget* functions should be called before
+    // DragSource* mthods. This function is only used when window rendering is
+    // disabled.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        int x,
+        int y,
+        cef_drag_operations_mask_t op) nothrow drag_source_ended_at;
+
+    ///
+    // Call this function when the drag operation started by a
+    // cef_render_handler_t::StartDragging call has completed. This function may
+    // be called immediately without first calling DragSourceEndedAt to cancel a
+    // drag operation. If the web view is both the drag source and the drag target
+    // then all DragTarget* functions should be called before DragSource* mthods.
+    // This function is only used when window rendering is disabled.
+    ///
+    extern(System) void function (cef_browser_host_t* self) nothrow drag_source_system_drag_ended;
+
+    ///
+    // Returns the current visible navigation entry for this browser. This
+    // function can only be called on the UI thread.
+    ///
+    extern(System) cef_navigation_entry_t* function (
+        cef_browser_host_t* self) nothrow get_visible_navigation_entry;
+
+    ///
+    // Set accessibility state for all frames. |accessibility_state| may be
+    // default, enabled or disabled. If |accessibility_state| is STATE_DEFAULT
+    // then accessibility will be disabled by default and the state may be further
+    // controlled with the "force-renderer-accessibility" and "disable-renderer-
+    // accessibility" command-line switches. If |accessibility_state| is
+    // STATE_ENABLED then accessibility will be enabled. If |accessibility_state|
+    // is STATE_DISABLED then accessibility will be completely disabled.
+    //
+    // For windowed browsers accessibility will be enabled in Complete mode (which
+    // corresponds to kAccessibilityModeComplete in Chromium). In this mode all
+    // platform accessibility objects will be created and managed by Chromium's
+    // internal implementation. The client needs only to detect the screen reader
+    // and call this function appropriately. For example, on macOS the client can
+    // handle the @"AXEnhancedUserStructure" accessibility attribute to detect
+    // VoiceOver state changes and on Windows the client can handle WM_GETOBJECT
+    // with OBJID_CLIENT to detect accessibility readers.
+    //
+    // For windowless browsers accessibility will be enabled in TreeOnly mode
+    // (which corresponds to kAccessibilityModeWebContentsOnly in Chromium). In
+    // this mode renderer accessibility is enabled, the full tree is computed, and
+    // events are passed to CefAccessibiltyHandler, but platform accessibility
+    // objects are not created. The client may implement platform accessibility
+    // objects using CefAccessibiltyHandler callbacks if desired.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        cef_state_t accessibility_state) nothrow set_accessibility_state;
+
+    ///
+    // Enable notifications of auto resize via
+    // cef_display_handler_t::OnAutoResize. Notifications are disabled by default.
+    // |min_size| and |max_size| define the range of allowed sizes.
+    ///
+    extern(System) void function (
+        cef_browser_host_t* self,
+        int enabled,
+        const(cef_size_t)* min_size,
+        const(cef_size_t)* max_size) nothrow set_auto_resize_enabled;
+
+    ///
+    // Returns the extension hosted in this browser or NULL if no extension is
+    // hosted. See cef_request_context_t::LoadExtension for details.
+    ///
+    extern(System) cef_extension_t* function (cef_browser_host_t* self) nothrow get_extension;
+
+    ///
+    // Returns true (1) if this browser is hosting an extension background script.
+    // Background hosts do not have a window and are not displayable. See
+    // cef_request_context_t::LoadExtension for details.
+    ///
+    extern(System) int function (cef_browser_host_t* self) nothrow is_background_host;
+
+    ///
+    //  Set whether the browser's audio is muted.
+    ///
+    extern(System) void function (cef_browser_host_t* self, int mute) nothrow set_audio_muted;
+
+    ///
+    // Returns true (1) if the browser's audio is muted.  This function can only
+    // be called on the UI thread.
+    ///
+    extern(System) int function (cef_browser_host_t* self) nothrow is_audio_muted;
+}
+
+
+
+///
+// Create a new browser using the window parameters specified by |windowInfo|.
+// All values will be copied internally and the actual window (if any) will be
+// created on the UI thread. If |request_context| is NULL the global request
+// context will be used. This function can be called on any browser process
+// thread and will not block. The optional |extra_info| parameter provides an
+// opportunity to specify extra information specific to the created browser that
+// will be passed to cef_render_process_handler_t::on_browser_created() in the
+// render process.
+///
+int cef_browser_host_create_browser (
+    const(cef_window_info_t)* windowInfo,
+    cef_client_t* client,
+    const(cef_string_t)* url,
+    const(cef_browser_settings_t)* settings,
+    cef_dictionary_value_t* extra_info,
+    cef_request_context_t* request_context);
+
+///
+// Create a new browser using the window parameters specified by |windowInfo|.
+// If |request_context| is NULL the global request context will be used. This
+// function can only be called on the browser process UI thread. The optional
+// |extra_info| parameter provides an opportunity to specify extra information
+// specific to the created browser that will be passed to
+// cef_render_process_handler_t::on_browser_created() in the render process.
+///
+cef_browser_t* cef_browser_host_create_browser_sync (
+    const(cef_window_info_t)* windowInfo,
+    cef_client_t* client,
+    const(cef_string_t)* url,
+    const(cef_browser_settings_t)* settings,
+    cef_dictionary_value_t* extra_info,
+    cef_request_context_t* request_context);
+
+// CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=ade537f836add7fe0b5fd94ceba26d678abb3e43$
+//
+
+extern (C):
+
+///
+// Structure used to implement browser process callbacks. The functions of this
+// structure will be called on the browser process main thread unless otherwise
+// indicated.
+///
+struct cef_browser_process_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called on the browser process UI thread immediately after the CEF context
+    // has been initialized.
+    ///
+    extern(System) void function (
+        cef_browser_process_handler_t* self) nothrow on_context_initialized;
+
+    ///
+    // Called before a child process is launched. Will be called on the browser
+    // process UI thread when launching a render process and on the browser
+    // process IO thread when launching a GPU or plugin process. Provides an
+    // opportunity to modify the child process command line. Do not keep a
+    // reference to |command_line| outside of this function.
+    ///
+    extern(System) void function (
+        cef_browser_process_handler_t* self,
+        cef_command_line_t* command_line) nothrow on_before_child_process_launch;
+
+    ///
+    // Called from any thread when work has been scheduled for the browser process
+    // main (UI) thread. This callback is used in combination with CefSettings.
+    // external_message_pump and cef_do_message_loop_work() in cases where the CEF
+    // message loop must be integrated into an existing application message loop
+    // (see additional comments and warnings on CefDoMessageLoopWork). This
+    // callback should schedule a cef_do_message_loop_work() call to happen on the
+    // main (UI) thread. |delay_ms| is the requested delay in milliseconds. If
+    // |delay_ms| is <= 0 then the call should happen reasonably soon. If
+    // |delay_ms| is > 0 then the call should be scheduled to happen after the
+    // specified delay and any currently pending scheduled call should be
+    // cancelled.
+    ///
+    extern(System) void function (
+        cef_browser_process_handler_t* self,
+        int64 delay_ms) nothrow on_schedule_message_pump_work;
+
+    ///
+    // Return the default client for use with a newly created browser window. If
+    // null is returned the browser will be unmanaged (no callbacks will be
+    // executed for that browser) and application shutdown will be blocked until
+    // the browser window is closed manually. This function is currently only used
+    // with the chrome runtime.
+    ///
+    extern(System) cef_client_t* function (
+        cef_browser_process_handler_t* self) nothrow get_default_client;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_BROWSER_PROCESS_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=cd8c183355a6808abd763ecc0396b5da6c15b3f9$
+//
+
+extern (C):
+
+///
+// Generic callback structure used for asynchronous continuation.
+///
+struct cef_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Continue processing.
+    ///
+    extern(System) void function (cef_callback_t* self) nothrow cont;
+
+    ///
+    // Cancel processing.
+    ///
+    extern(System) void function (cef_callback_t* self) nothrow cancel;
+}
+
+
+
+///
+// Generic callback structure used for asynchronous completion.
+///
+struct cef_completion_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be called once the task is complete.
+    ///
+    extern(System) void function (cef_completion_callback_t* self) nothrow on_complete;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_CALLBACK_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=845a1d1dda63a06f4ae33ed39acfd2599b46a885$
+//
+
+extern (C):
+
+///
+// Implement this structure to provide handler implementations.
+///
+struct cef_client_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Return the handler for audio rendering events.
+    ///
+    extern(System) cef_audio_handler_t* function (cef_client_t* self) nothrow get_audio_handler;
+
+    ///
+    // Return the handler for context menus. If no handler is provided the default
+    // implementation will be used.
+    ///
+    extern(System) cef_context_menu_handler_t* function (
+        cef_client_t* self) nothrow get_context_menu_handler;
+
+    ///
+    // Return the handler for dialogs. If no handler is provided the default
+    // implementation will be used.
+    ///
+    extern(System) cef_dialog_handler_t* function (cef_client_t* self) nothrow get_dialog_handler;
+
+    ///
+    // Return the handler for browser display state events.
+    ///
+    extern(System) cef_display_handler_t* function (cef_client_t* self) nothrow get_display_handler;
+
+    ///
+    // Return the handler for download events. If no handler is returned downloads
+    // will not be allowed.
+    ///
+    extern(System) cef_download_handler_t* function (
+        cef_client_t* self) nothrow get_download_handler;
+
+    ///
+    // Return the handler for drag events.
+    ///
+    extern(System) cef_drag_handler_t* function (cef_client_t* self) nothrow get_drag_handler;
+
+    ///
+    // Return the handler for find result events.
+    ///
+    extern(System) cef_find_handler_t* function (cef_client_t* self) nothrow get_find_handler;
+
+    ///
+    // Return the handler for focus events.
+    ///
+    extern(System) cef_focus_handler_t* function (cef_client_t* self) nothrow get_focus_handler;
+
+    ///
+    // Return the handler for events related to cef_frame_t lifespan. This
+    // function will be called once during cef_browser_t creation and the result
+    // will be cached for performance reasons.
+    ///
+    extern(System) cef_frame_handler_t* function (cef_client_t* self) nothrow get_frame_handler;
+
+    ///
+    // Return the handler for JavaScript dialogs. If no handler is provided the
+    // default implementation will be used.
+    ///
+    extern(System) cef_jsdialog_handler_t* function (
+        cef_client_t* self) nothrow get_jsdialog_handler;
+
+    ///
+    // Return the handler for keyboard events.
+    ///
+    extern(System) cef_keyboard_handler_t* function (
+        cef_client_t* self) nothrow get_keyboard_handler;
+
+    ///
+    // Return the handler for browser life span events.
+    ///
+    extern(System) cef_life_span_handler_t* function (
+        cef_client_t* self) nothrow get_life_span_handler;
+
+    ///
+    // Return the handler for browser load status events.
+    ///
+    extern(System) cef_load_handler_t* function (cef_client_t* self) nothrow get_load_handler;
+
+    ///
+    // Return the handler for printing on Linux. If a print handler is not
+    // provided then printing will not be supported on the Linux platform.
+    ///
+    extern(System) cef_print_handler_t* function (cef_client_t* self) nothrow get_print_handler;
+
+    ///
+    // Return the handler for off-screen rendering events.
+    ///
+    extern(System) cef_render_handler_t* function (cef_client_t* self) nothrow get_render_handler;
+
+    ///
+    // Return the handler for browser request events.
+    ///
+    extern(System) cef_request_handler_t* function (cef_client_t* self) nothrow get_request_handler;
+
+    ///
+    // Called when a new message is received from a different process. Return true
+    // (1) if the message was handled or false (0) otherwise.  It is safe to keep
+    // a reference to |message| outside of this callback.
+    ///
+    extern(System) int function (
+        cef_client_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_process_id_t source_process,
+        cef_process_message_t* message) nothrow on_process_message_received;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_CLIENT_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=3ecebd6b30bb8fb837e062eacd021c1a1ff3620a$
+//
+
+extern (C):
+
+///
+// Structure used to create and/or parse command line arguments. Arguments with
+// '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
+// will always precede any arguments without switch prefixes. Switches can
+// optionally have a value specified using the '=' delimiter (e.g.
+// "-switch=value"). An argument of "--" will terminate switch parsing with all
+// subsequent tokens, regardless of prefix, being interpreted as non-switch
+// arguments. Switch names should be lowercase ASCII and will be converted to
+// such if necessary. Switch values will retain the original case and UTF8
+// encoding. This structure can be used before cef_initialize() is called.
+///
+struct cef_command_line_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is valid. Do not call any other functions
+    // if this function returns false (0).
+    ///
+    extern(System) int function (cef_command_line_t* self) nothrow is_valid;
+
+    ///
+    // Returns true (1) if the values of this object are read-only. Some APIs may
+    // expose read-only objects.
+    ///
+    extern(System) int function (cef_command_line_t* self) nothrow is_read_only;
+
+    ///
+    // Returns a writable copy of this object.
+    ///
+    extern(System) cef_command_line_t* function (cef_command_line_t* self) nothrow copy;
+
+    ///
+    // Initialize the command line with the specified |argc| and |argv| values.
+    // The first argument must be the name of the program. This function is only
+    // supported on non-Windows platforms.
+    ///
+    extern(System) void function (
+        cef_command_line_t* self,
+        int argc,
+        const(char*)* argv) nothrow init_from_argv;
+
+    ///
+    // Initialize the command line with the string returned by calling
+    // GetCommandLineW(). This function is only supported on Windows.
+    ///
+    extern(System) void function (
+        cef_command_line_t* self,
+        const(cef_string_t)* command_line) nothrow init_from_string;
+
+    ///
+    // Reset the command-line switches and arguments but leave the program
+    // component unchanged.
+    ///
+    extern(System) void function (cef_command_line_t* self) nothrow reset;
+
+    ///
+    // Retrieve the original command line string as a vector of strings. The argv
+    // array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
+    ///
+    extern(System) void function (cef_command_line_t* self, cef_string_list_t argv) nothrow get_argv;
+
+    ///
+    // Constructs and returns the represented command line string. Use this
+    // function cautiously because quoting behavior is unclear.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_command_line_t* self) nothrow get_command_line_string;
+
+    ///
+    // Get the program part of the command line string (the first item).
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_command_line_t* self) nothrow get_program;
+
+    ///
+    // Set the program part of the command line string (the first item).
+    ///
+    extern(System) void function (
+        cef_command_line_t* self,
+        const(cef_string_t)* program) nothrow set_program;
+
+    ///
+    // Returns true (1) if the command line has switches.
+    ///
+    extern(System) int function (cef_command_line_t* self) nothrow has_switches;
+
+    ///
+    // Returns true (1) if the command line contains the given switch.
+    ///
+    extern(System) int function (
+        cef_command_line_t* self,
+        const(cef_string_t)* name) nothrow has_switch;
+
+    ///
+    // Returns the value associated with the given switch. If the switch has no
+    // value or isn't present this function returns the NULL string.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_command_line_t* self,
+        const(cef_string_t)* name) nothrow get_switch_value;
+
+    ///
+    // Returns the map of switch names and values. If a switch has no value an
+    // NULL string is returned.
+    ///
+    extern(System) void function (
+        cef_command_line_t* self,
+        cef_string_map_t switches) nothrow get_switches;
+
+    ///
+    // Add a switch to the end of the command line. If the switch has no value
+    // pass an NULL value string.
+    ///
+    extern(System) void function (
+        cef_command_line_t* self,
+        const(cef_string_t)* name) nothrow append_switch;
+
+    ///
+    // Add a switch with the specified value to the end of the command line.
+    ///
+    extern(System) void function (
+        cef_command_line_t* self,
+        const(cef_string_t)* name,
+        const(cef_string_t)* value) nothrow append_switch_with_value;
+
+    ///
+    // True if there are remaining command line arguments.
+    ///
+    extern(System) int function (cef_command_line_t* self) nothrow has_arguments;
+
+    ///
+    // Get the remaining command line arguments.
+    ///
+    extern(System) void function (
+        cef_command_line_t* self,
+        cef_string_list_t arguments) nothrow get_arguments;
+
+    ///
+    // Add an argument to the end of the command line.
+    ///
+    extern(System) void function (
+        cef_command_line_t* self,
+        const(cef_string_t)* argument) nothrow append_argument;
+
+    ///
+    // Insert a command before the current command. Common for debuggers, like
+    // "valgrind" or "gdb --args".
+    ///
+    extern(System) void function (
+        cef_command_line_t* self,
+        const(cef_string_t)* wrapper) nothrow prepend_wrapper;
+}
+
+
+
+///
+// Create a new cef_command_line_t instance.
+///
+cef_command_line_t* cef_command_line_create ();
+
+///
+// Returns the singleton global cef_command_line_t object. The returned object
+// will be read-only.
+///
+cef_command_line_t* cef_command_line_get_global ();
+
+// CEF_INCLUDE_CAPI_CEF_COMMAND_LINE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=175779df75a1405fcc5c337a09e6322c556698ba$
+//
+
+extern (C):
+
+///
+// Callback structure used for continuation of custom context menu display.
+///
+struct cef_run_context_menu_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Complete context menu display by selecting the specified |command_id| and
+    // |event_flags|.
+    ///
+    extern(System) void function (
+        cef_run_context_menu_callback_t* self,
+        int command_id,
+        cef_event_flags_t event_flags) nothrow cont;
+
+    ///
+    // Cancel context menu display.
+    ///
+    extern(System) void function (cef_run_context_menu_callback_t* self) nothrow cancel;
+}
+
+
+
+///
+// Implement this structure to handle context menu events. The functions of this
+// structure will be called on the UI thread.
+///
+struct cef_context_menu_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called before a context menu is displayed. |params| provides information
+    // about the context menu state. |model| initially contains the default
+    // context menu. The |model| can be cleared to show no context menu or
+    // modified to show a custom menu. Do not keep references to |params| or
+    // |model| outside of this callback.
+    ///
+    extern(System) void function (
+        cef_context_menu_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_context_menu_params_t* params,
+        cef_menu_model_t* model) nothrow on_before_context_menu;
+
+    ///
+    // Called to allow custom display of the context menu. |params| provides
+    // information about the context menu state. |model| contains the context menu
+    // model resulting from OnBeforeContextMenu. For custom display return true
+    // (1) and execute |callback| either synchronously or asynchronously with the
+    // selected command ID. For default display return false (0). Do not keep
+    // references to |params| or |model| outside of this callback.
+    ///
+    extern(System) int function (
+        cef_context_menu_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_context_menu_params_t* params,
+        cef_menu_model_t* model,
+        cef_run_context_menu_callback_t* callback) nothrow run_context_menu;
+
+    ///
+    // Called to execute a command selected from the context menu. Return true (1)
+    // if the command was handled or false (0) for the default implementation. See
+    // cef_menu_id_t for the command ids that have default implementations. All
+    // user-defined command ids should be between MENU_ID_USER_FIRST and
+    // MENU_ID_USER_LAST. |params| will have the same values as what was passed to
+    // on_before_context_menu(). Do not keep a reference to |params| outside of
+    // this callback.
+    ///
+    extern(System) int function (
+        cef_context_menu_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_context_menu_params_t* params,
+        int command_id,
+        cef_event_flags_t event_flags) nothrow on_context_menu_command;
+
+    ///
+    // Called when the context menu is dismissed irregardless of whether the menu
+    // was NULL or a command was selected.
+    ///
+    extern(System) void function (
+        cef_context_menu_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame) nothrow on_context_menu_dismissed;
+}
+
+
+
+///
+// Provides information about the context menu state. The ethods of this
+// structure can only be accessed on browser process the UI thread.
+///
+struct cef_context_menu_params_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the X coordinate of the mouse where the context menu was invoked.
+    // Coords are relative to the associated RenderView's origin.
+    ///
+    extern(System) int function (cef_context_menu_params_t* self) nothrow get_xcoord;
+
+    ///
+    // Returns the Y coordinate of the mouse where the context menu was invoked.
+    // Coords are relative to the associated RenderView's origin.
+    ///
+    extern(System) int function (cef_context_menu_params_t* self) nothrow get_ycoord;
+
+    ///
+    // Returns flags representing the type of node that the context menu was
+    // invoked on.
+    ///
+    extern(System) cef_context_menu_type_flags_t function (
+        cef_context_menu_params_t* self) nothrow get_type_flags;
+
+    ///
+    // Returns the URL of the link, if any, that encloses the node that the
+    // context menu was invoked on.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_context_menu_params_t* self) nothrow get_link_url;
+
+    ///
+    // Returns the link URL, if any, to be used ONLY for "copy link address". We
+    // don't validate this field in the frontend process.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_context_menu_params_t* self) nothrow get_unfiltered_link_url;
+
+    ///
+    // Returns the source URL, if any, for the element that the context menu was
+    // invoked on. Example of elements with source URLs are img, audio, and video.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_context_menu_params_t* self) nothrow get_source_url;
+
+    ///
+    // Returns true (1) if the context menu was invoked on an image which has non-
+    // NULL contents.
+    ///
+    extern(System) int function (cef_context_menu_params_t* self) nothrow has_image_contents;
+
+    ///
+    // Returns the title text or the alt text if the context menu was invoked on
+    // an image.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_context_menu_params_t* self) nothrow get_title_text;
+
+    ///
+    // Returns the URL of the top level page that the context menu was invoked on.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_context_menu_params_t* self) nothrow get_page_url;
+
+    ///
+    // Returns the URL of the subframe that the context menu was invoked on.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_context_menu_params_t* self) nothrow get_frame_url;
+
+    ///
+    // Returns the character encoding of the subframe that the context menu was
+    // invoked on.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_context_menu_params_t* self) nothrow get_frame_charset;
+
+    ///
+    // Returns the type of context node that the context menu was invoked on.
+    ///
+    extern(System) cef_context_menu_media_type_t function (
+        cef_context_menu_params_t* self) nothrow get_media_type;
+
+    ///
+    // Returns flags representing the actions supported by the media element, if
+    // any, that the context menu was invoked on.
+    ///
+    extern(System) cef_context_menu_media_state_flags_t function (
+        cef_context_menu_params_t* self) nothrow get_media_state_flags;
+
+    ///
+    // Returns the text of the selection, if any, that the context menu was
+    // invoked on.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_context_menu_params_t* self) nothrow get_selection_text;
+
+    ///
+    // Returns the text of the misspelled word, if any, that the context menu was
+    // invoked on.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_context_menu_params_t* self) nothrow get_misspelled_word;
+
+    ///
+    // Returns true (1) if suggestions exist, false (0) otherwise. Fills in
+    // |suggestions| from the spell check service for the misspelled word if there
+    // is one.
+    ///
+    extern(System) int function (
+        cef_context_menu_params_t* self,
+        cef_string_list_t suggestions) nothrow get_dictionary_suggestions;
+
+    ///
+    // Returns true (1) if the context menu was invoked on an editable node.
+    ///
+    extern(System) int function (cef_context_menu_params_t* self) nothrow is_editable;
+
+    ///
+    // Returns true (1) if the context menu was invoked on an editable node where
+    // spell-check is enabled.
+    ///
+    extern(System) int function (cef_context_menu_params_t* self) nothrow is_spell_check_enabled;
+
+    ///
+    // Returns flags representing the actions supported by the editable node, if
+    // any, that the context menu was invoked on.
+    ///
+    extern(System) cef_context_menu_edit_state_flags_t function (
+        cef_context_menu_params_t* self) nothrow get_edit_state_flags;
+
+    ///
+    // Returns true (1) if the context menu contains items specified by the
+    // renderer process (for example, plugin placeholder or pepper plugin menu
+    // items).
+    ///
+    extern(System) int function (cef_context_menu_params_t* self) nothrow is_custom_menu;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_CONTEXT_MENU_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=b19ef1c8a781f8d59276357609fe64370bb8a107$
+//
+
+extern (C):
+
+///
+// Structure used for managing cookies. The functions of this structure may be
+// called on any thread unless otherwise indicated.
+///
+struct cef_cookie_manager_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Visit all cookies on the UI thread. The returned cookies are ordered by
+    // longest path, then by earliest creation date. Returns false (0) if cookies
+    // cannot be accessed.
+    ///
+    extern(System) int function (
+        cef_cookie_manager_t* self,
+        cef_cookie_visitor_t* visitor) nothrow visit_all_cookies;
+
+    ///
+    // Visit a subset of cookies on the UI thread. The results are filtered by the
+    // given url scheme, host, domain and path. If |includeHttpOnly| is true (1)
+    // HTTP-only cookies will also be included in the results. The returned
+    // cookies are ordered by longest path, then by earliest creation date.
+    // Returns false (0) if cookies cannot be accessed.
+    ///
+    extern(System) int function (
+        cef_cookie_manager_t* self,
+        const(cef_string_t)* url,
+        int includeHttpOnly,
+        cef_cookie_visitor_t* visitor) nothrow visit_url_cookies;
+
+    ///
+    // Sets a cookie given a valid URL and explicit user-provided cookie
+    // attributes. This function expects each attribute to be well-formed. It will
+    // check for disallowed characters (e.g. the ';' character is disallowed
+    // within the cookie value attribute) and fail without setting the cookie if
+    // such characters are found. If |callback| is non-NULL it will be executed
+    // asnychronously on the UI thread after the cookie has been set. Returns
+    // false (0) if an invalid URL is specified or if cookies cannot be accessed.
+    ///
+    extern(System) int function (
+        cef_cookie_manager_t* self,
+        const(cef_string_t)* url,
+        const(cef_cookie_t)* cookie,
+        cef_set_cookie_callback_t* callback) nothrow set_cookie;
+
+    ///
+    // Delete all cookies that match the specified parameters. If both |url| and
+    // |cookie_name| values are specified all host and domain cookies matching
+    // both will be deleted. If only |url| is specified all host cookies (but not
+    // domain cookies) irrespective of path will be deleted. If |url| is NULL all
+    // cookies for all hosts and domains will be deleted. If |callback| is non-
+    // NULL it will be executed asnychronously on the UI thread after the cookies
+    // have been deleted. Returns false (0) if a non-NULL invalid URL is specified
+    // or if cookies cannot be accessed. Cookies can alternately be deleted using
+    // the Visit*Cookies() functions.
+    ///
+    extern(System) int function (
+        cef_cookie_manager_t* self,
+        const(cef_string_t)* url,
+        const(cef_string_t)* cookie_name,
+        cef_delete_cookies_callback_t* callback) nothrow delete_cookies;
+
+    ///
+    // Flush the backing store (if any) to disk. If |callback| is non-NULL it will
+    // be executed asnychronously on the UI thread after the flush is complete.
+    // Returns false (0) if cookies cannot be accessed.
+    ///
+    extern(System) int function (
+        cef_cookie_manager_t* self,
+        cef_completion_callback_t* callback) nothrow flush_store;
+}
+
+
+
+///
+// Returns the global cookie manager. By default data will be stored at
+// CefSettings.cache_path if specified or in memory otherwise. If |callback| is
+// non-NULL it will be executed asnychronously on the UI thread after the
+// manager's storage has been initialized. Using this function is equivalent to
+// calling cef_request_context_t::cef_request_context_get_global_context()->GetD
+// efaultCookieManager().
+///
+cef_cookie_manager_t* cef_cookie_manager_get_global_manager (
+    cef_completion_callback_t* callback);
+
+///
+// Structure to implement for visiting cookie values. The functions of this
+// structure will always be called on the UI thread.
+///
+struct cef_cookie_visitor_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be called once for each cookie. |count| is the 0-based
+    // index for the current cookie. |total| is the total number of cookies. Set
+    // |deleteCookie| to true (1) to delete the cookie currently being visited.
+    // Return false (0) to stop visiting cookies. This function may never be
+    // called if no cookies are found.
+    ///
+    extern(System) int function (
+        cef_cookie_visitor_t* self,
+        const(cef_cookie_t)* cookie,
+        int count,
+        int total,
+        int* deleteCookie) nothrow visit;
+}
+
+
+
+///
+// Structure to implement to be notified of asynchronous completion via
+// cef_cookie_manager_t::set_cookie().
+///
+struct cef_set_cookie_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be called upon completion. |success| will be true (1) if
+    // the cookie was set successfully.
+    ///
+    extern(System) void function (cef_set_cookie_callback_t* self, int success) nothrow on_complete;
+}
+
+
+
+///
+// Structure to implement to be notified of asynchronous completion via
+// cef_cookie_manager_t::delete_cookies().
+///
+struct cef_delete_cookies_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be called upon completion. |num_deleted| will be the
+    // number of cookies that were deleted.
+    ///
+    extern(System) void function (
+        cef_delete_cookies_callback_t* self,
+        int num_deleted) nothrow on_complete;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_COOKIE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=5e19231e3476eef376c2742e8d375bee7bd4ea2d$
+//
+
+extern (C):
+
+///
+// Crash reporting is configured using an INI-style config file named
+// "crash_reporter.cfg". On Windows and Linux this file must be placed next to
+// the main application executable. On macOS this file must be placed in the
+// top-level app bundle Resources directory (e.g.
+// "<appname>.app/Contents/Resources"). File contents are as follows:
+//
+//  # Comments start with a hash character and must be on their own line.
+//
+//  [Config]
+//  ProductName=<Value of the "prod" crash key; defaults to "cef">
+//  ProductVersion=<Value of the "ver" crash key; defaults to the CEF version>
+//  AppName=<Windows only; App-specific folder name component for storing crash
+//           information; default to "CEF">
+//  ExternalHandler=<Windows only; Name of the external handler exe to use
+//                   instead of re-launching the main exe; default to empty>
+//  BrowserCrashForwardingEnabled=<macOS only; True if browser process crashes
+//                                 should be forwarded to the system crash
+//                                 reporter; default to false>
+//  ServerURL=<crash server URL; default to empty>
+//  RateLimitEnabled=<True if uploads should be rate limited; default to true>
+//  MaxUploadsPerDay=<Max uploads per 24 hours, used if rate limit is enabled;
+//                    default to 5>
+//  MaxDatabaseSizeInMb=<Total crash report disk usage greater than this value
+//                       will cause older reports to be deleted; default to 20>
+//  MaxDatabaseAgeInDays=<Crash reports older than this value will be deleted;
+//                        default to 5>
+//
+//  [CrashKeys]
+//  my_key1=<small|medium|large>
+//  my_key2=<small|medium|large>
+//
+// Config section:
+//
+// If "ProductName" and/or "ProductVersion" are set then the specified values
+// will be included in the crash dump metadata. On macOS if these values are set
+// to NULL then they will be retrieved from the Info.plist file using the
+// "CFBundleName" and "CFBundleShortVersionString" keys respectively.
+//
+// If "AppName" is set on Windows then crash report information (metrics,
+// database and dumps) will be stored locally on disk under the
+// "C:\Users\[CurrentUser]\AppData\Local\[AppName]\User Data" folder. On other
+// platforms the CefSettings.user_data_path value will be used.
+//
+// If "ExternalHandler" is set on Windows then the specified exe will be
+// launched as the crashpad-handler instead of re-launching the main process
+// exe. The value can be an absolute path or a path relative to the main exe
+// directory. On Linux the CefSettings.browser_subprocess_path value will be
+// used. On macOS the existing subprocess app bundle will be used.
+//
+// If "BrowserCrashForwardingEnabled" is set to true (1) on macOS then browser
+// process crashes will be forwarded to the system crash reporter. This results
+// in the crash UI dialog being displayed to the user and crash reports being
+// logged under "~/Library/Logs/DiagnosticReports". Forwarding of crash reports
+// from non-browser processes and Debug builds is always disabled.
+//
+// If "ServerURL" is set then crashes will be uploaded as a multi-part POST
+// request to the specified URL. Otherwise, reports will only be stored locally
+// on disk.
+//
+// If "RateLimitEnabled" is set to true (1) then crash report uploads will be
+// rate limited as follows:
+//  1. If "MaxUploadsPerDay" is set to a positive value then at most the
+//     specified number of crashes will be uploaded in each 24 hour period.
+//  2. If crash upload fails due to a network or server error then an
+//     incremental backoff delay up to a maximum of 24 hours will be applied for
+//     retries.
+//  3. If a backoff delay is applied and "MaxUploadsPerDay" is > 1 then the
+//     "MaxUploadsPerDay" value will be reduced to 1 until the client is
+//     restarted. This helps to avoid an upload flood when the network or
+//     server error is resolved.
+// Rate limiting is not supported on Linux.
+//
+// If "MaxDatabaseSizeInMb" is set to a positive value then crash report storage
+// on disk will be limited to that size in megabytes. For example, on Windows
+// each dump is about 600KB so a "MaxDatabaseSizeInMb" value of 20 equates to
+// about 34 crash reports stored on disk. Not supported on Linux.
+//
+// If "MaxDatabaseAgeInDays" is set to a positive value then crash reports older
+// than the specified age in days will be deleted. Not supported on Linux.
+//
+// CrashKeys section:
+//
+// A maximum of 26 crash keys of each size can be specified for use by the
+// application. Crash key values will be truncated based on the specified size
+// (small = 64 bytes, medium = 256 bytes, large = 1024 bytes). The value of
+// crash keys can be set from any thread or process using the
+// CefSetCrashKeyValue function. These key/value pairs will be sent to the crash
+// server along with the crash dump file.
+///
+int cef_crash_reporting_enabled ();
+
+///
+// Sets or clears a specific key-value pair from the crash metadata.
+///
+void cef_set_crash_key_value (
+    const(cef_string_t)* key,
+    const(cef_string_t)* value);
+
+// CEF_INCLUDE_CAPI_CEF_CRASH_UTIL_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=1a256c04042ebd4867f39e1c31def558871b2bab$
+//
+
+extern (C):
+
+
+
+///
+// Callback structure for cef_browser_host_t::AddDevToolsMessageObserver. The
+// functions of this structure will be called on the browser process UI thread.
+///
+struct cef_dev_tools_message_observer_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be called on receipt of a DevTools protocol message.
+    // |browser| is the originating browser instance. |message| is a UTF8-encoded
+    // JSON dictionary representing either a function result or an event.
+    // |message| is only valid for the scope of this callback and should be copied
+    // if necessary. Return true (1) if the message was handled or false (0) if
+    // the message should be further processed and passed to the
+    // OnDevToolsMethodResult or OnDevToolsEvent functions as appropriate.
+    //
+    // Method result dictionaries include an "id" (int) value that identifies the
+    // orginating function call sent from cef_browser_host_t::SendDevToolsMessage,
+    // and optionally either a "result" (dictionary) or "error" (dictionary)
+    // value. The "error" dictionary will contain "code" (int) and "message"
+    // (string) values. Event dictionaries include a "function" (string) value and
+    // optionally a "params" (dictionary) value. See the DevTools protocol
+    // documentation at https://chromedevtools.github.io/devtools-protocol/ for
+    // details of supported function calls and the expected "result" or "params"
+    // dictionary contents. JSON dictionaries can be parsed using the CefParseJSON
+    // function if desired, however be aware of performance considerations when
+    // parsing large messages (some of which may exceed 1MB in size).
+    ///
+    extern(System) int function (
+        cef_dev_tools_message_observer_t* self,
+        cef_browser_t* browser,
+        const(void)* message,
+        size_t message_size) nothrow on_dev_tools_message;
+
+    ///
+    // Method that will be called after attempted execution of a DevTools protocol
+    // function. |browser| is the originating browser instance. |message_id| is
+    // the "id" value that identifies the originating function call message. If
+    // the function succeeded |success| will be true (1) and |result| will be the
+    // UTF8-encoded JSON "result" dictionary value (which may be NULL). If the
+    // function failed |success| will be false (0) and |result| will be the
+    // UTF8-encoded JSON "error" dictionary value. |result| is only valid for the
+    // scope of this callback and should be copied if necessary. See the
+    // OnDevToolsMessage documentation for additional details on |result|
+    // contents.
+    ///
+    extern(System) void function (
+        cef_dev_tools_message_observer_t* self,
+        cef_browser_t* browser,
+        int message_id,
+        int success,
+        const(void)* result,
+        size_t result_size) nothrow on_dev_tools_method_result;
+
+    ///
+    // Method that will be called on receipt of a DevTools protocol event.
+    // |browser| is the originating browser instance. |function| is the "function"
+    // value. |params| is the UTF8-encoded JSON "params" dictionary value (which
+    // may be NULL). |params| is only valid for the scope of this callback and
+    // should be copied if necessary. See the OnDevToolsMessage documentation for
+    // additional details on |params| contents.
+    ///
+    extern(System) void function (
+        cef_dev_tools_message_observer_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* method,
+        const(void)* params,
+        size_t params_size) nothrow on_dev_tools_event;
+
+    ///
+    // Method that will be called when the DevTools agent has attached. |browser|
+    // is the originating browser instance. This will generally occur in response
+    // to the first message sent while the agent is detached.
+    ///
+    extern(System) void function (
+        cef_dev_tools_message_observer_t* self,
+        cef_browser_t* browser) nothrow on_dev_tools_agent_attached;
+
+    ///
+    // Method that will be called when the DevTools agent has detached. |browser|
+    // is the originating browser instance. Any function results that were pending
+    // before the agent became detached will not be delivered, and any active
+    // event subscriptions will be canceled.
+    ///
+    extern(System) void function (
+        cef_dev_tools_message_observer_t* self,
+        cef_browser_t* browser) nothrow on_dev_tools_agent_detached;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_DEVTOOLS_MESSAGE_OBSERVER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=5ae5556e4085faf8cf17ee757f5eeac9197f75c0$
+//
+
+extern (C):
+
+///
+// Callback structure for asynchronous continuation of file dialog requests.
+///
+struct cef_file_dialog_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Continue the file selection. |selected_accept_filter| should be the 0-based
+    // index of the value selected from the accept filters array passed to
+    // cef_dialog_handler_t::OnFileDialog. |file_paths| should be a single value
+    // or a list of values depending on the dialog mode. An NULL |file_paths|
+    // value is treated the same as calling cancel().
+    ///
+    extern(System) void function (
+        cef_file_dialog_callback_t* self,
+        int selected_accept_filter,
+        cef_string_list_t file_paths) nothrow cont;
+
+    ///
+    // Cancel the file selection.
+    ///
+    extern(System) void function (cef_file_dialog_callback_t* self) nothrow cancel;
+}
+
+
+
+///
+// Implement this structure to handle dialog events. The functions of this
+// structure will be called on the browser process UI thread.
+///
+struct cef_dialog_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called to run a file chooser dialog. |mode| represents the type of dialog
+    // to display. |title| to the title to be used for the dialog and may be NULL
+    // to show the default title ("Open" or "Save" depending on the mode).
+    // |default_file_path| is the path with optional directory and/or file name
+    // component that should be initially selected in the dialog. |accept_filters|
+    // are used to restrict the selectable file types and may any combination of
+    // (a) valid lower-cased MIME types (e.g. "text/*" or "image/*"), (b)
+    // individual file extensions (e.g. ".txt" or ".png"), or (c) combined
+    // description and file extension delimited using "|" and ";" (e.g. "Image
+    // Types|.png;.gif;.jpg"). |selected_accept_filter| is the 0-based index of
+    // the filter that should be selected by default. To display a custom dialog
+    // return true (1) and execute |callback| either inline or at a later time. To
+    // display the default dialog return false (0).
+    ///
+    extern(System) int function (
+        cef_dialog_handler_t* self,
+        cef_browser_t* browser,
+        cef_file_dialog_mode_t mode,
+        const(cef_string_t)* title,
+        const(cef_string_t)* default_file_path,
+        cef_string_list_t accept_filters,
+        int selected_accept_filter,
+        cef_file_dialog_callback_t* callback) nothrow on_file_dialog;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_DIALOG_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=067fd169a30bec1ad8eeacc5ab1ac750cf59640e$
+//
+
+import core.stdc.config;
+
+extern (C):
+
+///
+// Implement this structure to handle events related to browser display state.
+// The functions of this structure will be called on the UI thread.
+///
+struct cef_display_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called when a frame's address has changed.
+    ///
+    extern(System) void function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        const(cef_string_t)* url) nothrow on_address_change;
+
+    ///
+    // Called when the page title changes.
+    ///
+    extern(System) void function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* title) nothrow on_title_change;
+
+    ///
+    // Called when the page icon changes.
+    ///
+    extern(System) void function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        cef_string_list_t icon_urls) nothrow on_favicon_urlchange;
+
+    ///
+    // Called when web content in the page has toggled fullscreen mode. If
+    // |fullscreen| is true (1) the content will automatically be sized to fill
+    // the browser content area. If |fullscreen| is false (0) the content will
+    // automatically return to its original size and position. The client is
+    // responsible for resizing the browser if desired.
+    ///
+    extern(System) void function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        int fullscreen) nothrow on_fullscreen_mode_change;
+
+    ///
+    // Called when the browser is about to display a tooltip. |text| contains the
+    // text that will be displayed in the tooltip. To handle the display of the
+    // tooltip yourself return true (1). Otherwise, you can optionally modify
+    // |text| and then return false (0) to allow the browser to display the
+    // tooltip. When window rendering is disabled the application is responsible
+    // for drawing tooltips and the return value is ignored.
+    ///
+    extern(System) int function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        cef_string_t* text) nothrow on_tooltip;
+
+    ///
+    // Called when the browser receives a status message. |value| contains the
+    // text that will be displayed in the status message.
+    ///
+    extern(System) void function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* value) nothrow on_status_message;
+
+    ///
+    // Called to display a console message. Return true (1) to stop the message
+    // from being output to the console.
+    ///
+    extern(System) int function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        cef_log_severity_t level,
+        const(cef_string_t)* message,
+        const(cef_string_t)* source,
+        int line) nothrow on_console_message;
+
+    ///
+    // Called when auto-resize is enabled via
+    // cef_browser_host_t::SetAutoResizeEnabled and the contents have auto-
+    // resized. |new_size| will be the desired size in view coordinates. Return
+    // true (1) if the resize was handled or false (0) for default handling.
+    ///
+    extern(System) int function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_size_t)* new_size) nothrow on_auto_resize;
+
+    ///
+    // Called when the overall page loading progress has changed. |progress|
+    // ranges from 0.0 to 1.0.
+    ///
+    extern(System) void function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        double progress) nothrow on_loading_progress_change;
+
+    ///
+    // Called when the browser's cursor has changed. If |type| is CT_CUSTOM then
+    // |custom_cursor_info| will be populated with the custom cursor information.
+    // Return true (1) if the cursor change was handled or false (0) for default
+    // handling.
+    ///
+    extern(System) int function (
+        cef_display_handler_t* self,
+        cef_browser_t* browser,
+        c_ulong cursor,
+        cef_cursor_type_t type,
+        const(cef_cursor_info_t)* custom_cursor_info) nothrow on_cursor_change;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=0517dc6c42fdde9fecfc4549fab1ea12b614e143$
+//
+
+extern (C):
+
+///
+// Structure to implement for visiting the DOM. The functions of this structure
+// will be called on the render process main thread.
+///
+struct cef_domvisitor_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method executed for visiting the DOM. The document object passed to this
+    // function represents a snapshot of the DOM at the time this function is
+    // executed. DOM objects are only valid for the scope of this function. Do not
+    // keep references to or attempt to access any DOM objects outside the scope
+    // of this function.
+    ///
+    extern(System) void function (
+        cef_domvisitor_t* self,
+        cef_domdocument_t* document) nothrow visit;
+}
+
+
+
+///
+// Structure used to represent a DOM document. The functions of this structure
+// should only be called on the render process main thread thread.
+///
+struct cef_domdocument_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the document type.
+    ///
+    extern(System) cef_dom_document_type_t function (cef_domdocument_t* self) nothrow get_type;
+
+    ///
+    // Returns the root document node.
+    ///
+    extern(System) cef_domnode_t* function (cef_domdocument_t* self) nothrow get_document;
+
+    ///
+    // Returns the BODY node of an HTML document.
+    ///
+    extern(System) cef_domnode_t* function (cef_domdocument_t* self) nothrow get_body;
+
+    ///
+    // Returns the HEAD node of an HTML document.
+    ///
+    extern(System) cef_domnode_t* function (cef_domdocument_t* self) nothrow get_head;
+
+    ///
+    // Returns the title of an HTML document.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_domdocument_t* self) nothrow get_title;
+
+    ///
+    // Returns the document element with the specified ID value.
+    ///
+    extern(System) cef_domnode_t* function (
+        cef_domdocument_t* self,
+        const(cef_string_t)* id) nothrow get_element_by_id;
+
+    ///
+    // Returns the node that currently has keyboard focus.
+    ///
+    extern(System) cef_domnode_t* function (cef_domdocument_t* self) nothrow get_focused_node;
+
+    ///
+    // Returns true (1) if a portion of the document is selected.
+    ///
+    extern(System) int function (cef_domdocument_t* self) nothrow has_selection;
+
+    ///
+    // Returns the selection offset within the start node.
+    ///
+    extern(System) int function (cef_domdocument_t* self) nothrow get_selection_start_offset;
+
+    ///
+    // Returns the selection offset within the end node.
+    ///
+    extern(System) int function (cef_domdocument_t* self) nothrow get_selection_end_offset;
+
+    ///
+    // Returns the contents of this selection as markup.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_domdocument_t* self) nothrow get_selection_as_markup;
+
+    ///
+    // Returns the contents of this selection as text.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_domdocument_t* self) nothrow get_selection_as_text;
+
+    ///
+    // Returns the base URL for the document.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_domdocument_t* self) nothrow get_base_url;
+
+    ///
+    // Returns a complete URL based on the document base URL and the specified
+    // partial URL.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_domdocument_t* self,
+        const(cef_string_t)* partialURL) nothrow get_complete_url;
+}
+
+
+
+///
+// Structure used to represent a DOM node. The functions of this structure
+// should only be called on the render process main thread.
+///
+struct cef_domnode_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the type for this node.
+    ///
+    extern(System) cef_dom_node_type_t function (cef_domnode_t* self) nothrow get_type;
+
+    ///
+    // Returns true (1) if this is a text node.
+    ///
+    extern(System) int function (cef_domnode_t* self) nothrow is_text;
+
+    ///
+    // Returns true (1) if this is an element node.
+    ///
+    extern(System) int function (cef_domnode_t* self) nothrow is_element;
+
+    ///
+    // Returns true (1) if this is an editable node.
+    ///
+    extern(System) int function (cef_domnode_t* self) nothrow is_editable;
+
+    ///
+    // Returns true (1) if this is a form control element node.
+    ///
+    extern(System) int function (cef_domnode_t* self) nothrow is_form_control_element;
+
+    ///
+    // Returns the type of this form control element node.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_domnode_t* self) nothrow get_form_control_element_type;
+
+    ///
+    // Returns true (1) if this object is pointing to the same handle as |that|
+    // object.
+    ///
+    extern(System) int function (cef_domnode_t* self, cef_domnode_t* that) nothrow is_same;
+
+    ///
+    // Returns the name of this node.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_domnode_t* self) nothrow get_name;
+
+    ///
+    // Returns the value of this node.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_domnode_t* self) nothrow get_value;
+
+    ///
+    // Set the value of this node. Returns true (1) on success.
+    ///
+    extern(System) int function (cef_domnode_t* self, const(cef_string_t)* value) nothrow set_value;
+
+    ///
+    // Returns the contents of this node as markup.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_domnode_t* self) nothrow get_as_markup;
+
+    ///
+    // Returns the document associated with this node.
+    ///
+    extern(System) cef_domdocument_t* function (cef_domnode_t* self) nothrow get_document;
+
+    ///
+    // Returns the parent node.
+    ///
+    extern(System) cef_domnode_t* function (cef_domnode_t* self) nothrow get_parent;
+
+    ///
+    // Returns the previous sibling node.
+    ///
+    extern(System) cef_domnode_t* function (cef_domnode_t* self) nothrow get_previous_sibling;
+
+    ///
+    // Returns the next sibling node.
+    ///
+    extern(System) cef_domnode_t* function (cef_domnode_t* self) nothrow get_next_sibling;
+
+    ///
+    // Returns true (1) if this node has child nodes.
+    ///
+    extern(System) int function (cef_domnode_t* self) nothrow has_children;
+
+    ///
+    // Return the first child node.
+    ///
+    extern(System) cef_domnode_t* function (cef_domnode_t* self) nothrow get_first_child;
+
+    ///
+    // Returns the last child node.
+    ///
+    extern(System) cef_domnode_t* function (cef_domnode_t* self) nothrow get_last_child;
+
+    // The following functions are valid only for element nodes.
+
+    ///
+    // Returns the tag name of this element.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_domnode_t* self) nothrow get_element_tag_name;
+
+    ///
+    // Returns true (1) if this element has attributes.
+    ///
+    extern(System) int function (cef_domnode_t* self) nothrow has_element_attributes;
+
+    ///
+    // Returns true (1) if this element has an attribute named |attrName|.
+    ///
+    extern(System) int function (
+        cef_domnode_t* self,
+        const(cef_string_t)* attrName) nothrow has_element_attribute;
+
+    ///
+    // Returns the element attribute named |attrName|.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_domnode_t* self,
+        const(cef_string_t)* attrName) nothrow get_element_attribute;
+
+    ///
+    // Returns a map of all element attributes.
+    ///
+    extern(System) void function (
+        cef_domnode_t* self,
+        cef_string_map_t attrMap) nothrow get_element_attributes;
+
+    ///
+    // Set the value for the element attribute named |attrName|. Returns true (1)
+    // on success.
+    ///
+    extern(System) int function (
+        cef_domnode_t* self,
+        const(cef_string_t)* attrName,
+        const(cef_string_t)* value) nothrow set_element_attribute;
+
+    ///
+    // Returns the inner text of the element.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_domnode_t* self) nothrow get_element_inner_text;
+
+    ///
+    // Returns the bounds of the element.
+    ///
+    extern(System) cef_rect_t function (cef_domnode_t* self) nothrow get_element_bounds;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_DOM_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=f0ceb73b289072a01c45c6e7abf339a4ec924d29$
+//
+
+extern (C):
+
+///
+// Callback structure used to asynchronously continue a download.
+///
+struct cef_before_download_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Call to continue the download. Set |download_path| to the full file path
+    // for the download including the file name or leave blank to use the
+    // suggested name and the default temp directory. Set |show_dialog| to true
+    // (1) if you do wish to show the default "Save As" dialog.
+    ///
+    extern(System) void function (
+        cef_before_download_callback_t* self,
+        const(cef_string_t)* download_path,
+        int show_dialog) nothrow cont;
+}
+
+
+
+///
+// Callback structure used to asynchronously cancel a download.
+///
+struct cef_download_item_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Call to cancel the download.
+    ///
+    extern(System) void function (cef_download_item_callback_t* self) nothrow cancel;
+
+    ///
+    // Call to pause the download.
+    ///
+    extern(System) void function (cef_download_item_callback_t* self) nothrow pause;
+
+    ///
+    // Call to resume the download.
+    ///
+    extern(System) void function (cef_download_item_callback_t* self) nothrow resume;
+}
+
+
+
+///
+// Structure used to handle file downloads. The functions of this structure will
+// called on the browser process UI thread.
+///
+struct cef_download_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called before a download begins. |suggested_name| is the suggested name for
+    // the download file. By default the download will be canceled. Execute
+    // |callback| either asynchronously or in this function to continue the
+    // download if desired. Do not keep a reference to |download_item| outside of
+    // this function.
+    ///
+    extern(System) void function (
+        cef_download_handler_t* self,
+        cef_browser_t* browser,
+        cef_download_item_t* download_item,
+        const(cef_string_t)* suggested_name,
+        cef_before_download_callback_t* callback) nothrow on_before_download;
+
+    ///
+    // Called when a download's status or progress information has been updated.
+    // This may be called multiple times before and after on_before_download().
+    // Execute |callback| either asynchronously or in this function to cancel the
+    // download if desired. Do not keep a reference to |download_item| outside of
+    // this function.
+    ///
+    extern(System) void function (
+        cef_download_handler_t* self,
+        cef_browser_t* browser,
+        cef_download_item_t* download_item,
+        cef_download_item_callback_t* callback) nothrow on_download_updated;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_DOWNLOAD_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=d84044bb582b029af5fa46c75f35b3da948dffd2$
+//
+
+extern (C):
+
+///
+// Structure used to represent a download item.
+///
+struct cef_download_item_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is valid. Do not call any other functions
+    // if this function returns false (0).
+    ///
+    extern(System) int function (cef_download_item_t* self) nothrow is_valid;
+
+    ///
+    // Returns true (1) if the download is in progress.
+    ///
+    extern(System) int function (cef_download_item_t* self) nothrow is_in_progress;
+
+    ///
+    // Returns true (1) if the download is complete.
+    ///
+    extern(System) int function (cef_download_item_t* self) nothrow is_complete;
+
+    ///
+    // Returns true (1) if the download has been canceled or interrupted.
+    ///
+    extern(System) int function (cef_download_item_t* self) nothrow is_canceled;
+
+    ///
+    // Returns a simple speed estimate in bytes/s.
+    ///
+    extern(System) int64 function (cef_download_item_t* self) nothrow get_current_speed;
+
+    ///
+    // Returns the rough percent complete or -1 if the receive total size is
+    // unknown.
+    ///
+    extern(System) int function (cef_download_item_t* self) nothrow get_percent_complete;
+
+    ///
+    // Returns the total number of bytes.
+    ///
+    extern(System) int64 function (cef_download_item_t* self) nothrow get_total_bytes;
+
+    ///
+    // Returns the number of received bytes.
+    ///
+    extern(System) int64 function (cef_download_item_t* self) nothrow get_received_bytes;
+
+    ///
+    // Returns the time that the download started.
+    ///
+    extern(System) cef_time_t function (cef_download_item_t* self) nothrow get_start_time;
+
+    ///
+    // Returns the time that the download ended.
+    ///
+    extern(System) cef_time_t function (cef_download_item_t* self) nothrow get_end_time;
+
+    ///
+    // Returns the full path to the downloaded or downloading file.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_download_item_t* self) nothrow get_full_path;
+
+    ///
+    // Returns the unique identifier for this download.
+    ///
+    extern(System) uint32 function (cef_download_item_t* self) nothrow get_id;
+
+    ///
+    // Returns the URL.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_download_item_t* self) nothrow get_url;
+
+    ///
+    // Returns the original URL before any redirections.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_download_item_t* self) nothrow get_original_url;
+
+    ///
+    // Returns the suggested file name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_download_item_t* self) nothrow get_suggested_file_name;
+
+    ///
+    // Returns the content disposition.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_download_item_t* self) nothrow get_content_disposition;
+
+    ///
+    // Returns the mime type.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_download_item_t* self) nothrow get_mime_type;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_DOWNLOAD_ITEM_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=9663321e2be1d000ac54e195c81f210ae40773d1$
+//
+
+extern (C):
+
+///
+// Structure used to represent drag data. The functions of this structure may be
+// called on any thread.
+///
+struct cef_drag_data_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns a copy of the current object.
+    ///
+    extern(System) cef_drag_data_t* function (cef_drag_data_t* self) nothrow clone;
+
+    ///
+    // Returns true (1) if this object is read-only.
+    ///
+    extern(System) int function (cef_drag_data_t* self) nothrow is_read_only;
+
+    ///
+    // Returns true (1) if the drag data is a link.
+    ///
+    extern(System) int function (cef_drag_data_t* self) nothrow is_link;
+
+    ///
+    // Returns true (1) if the drag data is a text or html fragment.
+    ///
+    extern(System) int function (cef_drag_data_t* self) nothrow is_fragment;
+
+    ///
+    // Returns true (1) if the drag data is a file.
+    ///
+    extern(System) int function (cef_drag_data_t* self) nothrow is_file;
+
+    ///
+    // Return the link URL that is being dragged.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_drag_data_t* self) nothrow get_link_url;
+
+    ///
+    // Return the title associated with the link being dragged.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_drag_data_t* self) nothrow get_link_title;
+
+    ///
+    // Return the metadata, if any, associated with the link being dragged.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_drag_data_t* self) nothrow get_link_metadata;
+
+    ///
+    // Return the plain text fragment that is being dragged.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_drag_data_t* self) nothrow get_fragment_text;
+
+    ///
+    // Return the text/html fragment that is being dragged.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_drag_data_t* self) nothrow get_fragment_html;
+
+    ///
+    // Return the base URL that the fragment came from. This value is used for
+    // resolving relative URLs and may be NULL.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_drag_data_t* self) nothrow get_fragment_base_url;
+
+    ///
+    // Return the name of the file being dragged out of the browser window.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_drag_data_t* self) nothrow get_file_name;
+
+    ///
+    // Write the contents of the file being dragged out of the web view into
+    // |writer|. Returns the number of bytes sent to |writer|. If |writer| is NULL
+    // this function will return the size of the file contents in bytes. Call
+    // get_file_name() to get a suggested name for the file.
+    ///
+    extern(System) size_t function (
+        cef_drag_data_t* self,
+        cef_stream_writer_t* writer) nothrow get_file_contents;
+
+    ///
+    // Retrieve the list of file names that are being dragged into the browser
+    // window.
+    ///
+    extern(System) int function (
+        cef_drag_data_t* self,
+        cef_string_list_t names) nothrow get_file_names;
+
+    ///
+    // Set the link URL that is being dragged.
+    ///
+    extern(System) void function (
+        cef_drag_data_t* self,
+        const(cef_string_t)* url) nothrow set_link_url;
+
+    ///
+    // Set the title associated with the link being dragged.
+    ///
+    extern(System) void function (
+        cef_drag_data_t* self,
+        const(cef_string_t)* title) nothrow set_link_title;
+
+    ///
+    // Set the metadata associated with the link being dragged.
+    ///
+    extern(System) void function (
+        cef_drag_data_t* self,
+        const(cef_string_t)* data) nothrow set_link_metadata;
+
+    ///
+    // Set the plain text fragment that is being dragged.
+    ///
+    extern(System) void function (
+        cef_drag_data_t* self,
+        const(cef_string_t)* text) nothrow set_fragment_text;
+
+    ///
+    // Set the text/html fragment that is being dragged.
+    ///
+    extern(System) void function (
+        cef_drag_data_t* self,
+        const(cef_string_t)* html) nothrow set_fragment_html;
+
+    ///
+    // Set the base URL that the fragment came from.
+    ///
+    extern(System) void function (
+        cef_drag_data_t* self,
+        const(cef_string_t)* base_url) nothrow set_fragment_base_url;
+
+    ///
+    // Reset the file contents. You should do this before calling
+    // cef_browser_host_t::DragTargetDragEnter as the web view does not allow us
+    // to drag in this kind of data.
+    ///
+    extern(System) void function (cef_drag_data_t* self) nothrow reset_file_contents;
+
+    ///
+    // Add a file that is being dragged into the webview.
+    ///
+    extern(System) void function (
+        cef_drag_data_t* self,
+        const(cef_string_t)* path,
+        const(cef_string_t)* display_name) nothrow add_file;
+
+    ///
+    // Get the image representation of drag data. May return NULL if no image
+    // representation is available.
+    ///
+    extern(System) cef_image_t* function (cef_drag_data_t* self) nothrow get_image;
+
+    ///
+    // Get the image hotspot (drag start location relative to image dimensions).
+    ///
+    extern(System) cef_point_t function (cef_drag_data_t* self) nothrow get_image_hotspot;
+
+    ///
+    // Returns true (1) if an image representation of drag data is available.
+    ///
+    extern(System) int function (cef_drag_data_t* self) nothrow has_image;
+}
+
+
+
+///
+// Create a new cef_drag_data_t object.
+///
+cef_drag_data_t* cef_drag_data_create ();
+
+// CEF_INCLUDE_CAPI_CEF_DRAG_DATA_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=1cc1f134e68406ae3b05f7e181e12f27262772f0$
+//
+
+extern (C):
+
+///
+// Implement this structure to handle events related to dragging. The functions
+// of this structure will be called on the UI thread.
+///
+struct cef_drag_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called when an external drag event enters the browser window. |dragData|
+    // contains the drag event data and |mask| represents the type of drag
+    // operation. Return false (0) for default drag handling behavior or true (1)
+    // to cancel the drag event.
+    ///
+    extern(System) int function (
+        cef_drag_handler_t* self,
+        cef_browser_t* browser,
+        cef_drag_data_t* dragData,
+        cef_drag_operations_mask_t mask) nothrow on_drag_enter;
+
+    ///
+    // Called whenever draggable regions for the browser window change. These can
+    // be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If
+    // draggable regions are never defined in a document this function will also
+    // never be called. If the last draggable region is removed from a document
+    // this function will be called with an NULL vector.
+    ///
+    extern(System) void function (
+        cef_drag_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        size_t regionsCount,
+        const(cef_draggable_region_t)* regions) nothrow on_draggable_regions_changed;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_DRAG_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=5d5251098be1477705de2a21502dec2d8338ce00$
+//
+
+extern (C):
+
+
+
+
+///
+// Object representing an extension. Methods may be called on any thread unless
+// otherwise indicated.
+///
+struct cef_extension_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the unique extension identifier. This is calculated based on the
+    // extension public key, if available, or on the extension path. See
+    // https://developer.chrome.com/extensions/manifest/key for details.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_extension_t* self) nothrow get_identifier;
+
+    ///
+    // Returns the absolute path to the extension directory on disk. This value
+    // will be prefixed with PK_DIR_RESOURCES if a relative path was passed to
+    // cef_request_context_t::LoadExtension.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_extension_t* self) nothrow get_path;
+
+    ///
+    // Returns the extension manifest contents as a cef_dictionary_value_t object.
+    // See https://developer.chrome.com/extensions/manifest for details.
+    ///
+    extern(System) cef_dictionary_value_t* function (cef_extension_t* self) nothrow get_manifest;
+
+    ///
+    // Returns true (1) if this object is the same extension as |that| object.
+    // Extensions are considered the same if identifier, path and loader context
+    // match.
+    ///
+    extern(System) int function (cef_extension_t* self, cef_extension_t* that) nothrow is_same;
+
+    ///
+    // Returns the handler for this extension. Will return NULL for internal
+    // extensions or if no handler was passed to
+    // cef_request_context_t::LoadExtension.
+    ///
+    extern(System) cef_extension_handler_t* function (cef_extension_t* self) nothrow get_handler;
+
+    ///
+    // Returns the request context that loaded this extension. Will return NULL
+    // for internal extensions or if the extension has been unloaded. See the
+    // cef_request_context_t::LoadExtension documentation for more information
+    // about loader contexts. Must be called on the browser process UI thread.
+    ///
+    extern(System) cef_request_context_t* function (
+        cef_extension_t* self) nothrow get_loader_context;
+
+    ///
+    // Returns true (1) if this extension is currently loaded. Must be called on
+    // the browser process UI thread.
+    ///
+    extern(System) int function (cef_extension_t* self) nothrow is_loaded;
+
+    ///
+    // Unload this extension if it is not an internal extension and is currently
+    // loaded. Will result in a call to
+    // cef_extension_handler_t::OnExtensionUnloaded on success.
+    ///
+    extern(System) void function (cef_extension_t* self) nothrow unload;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_EXTENSION_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=c952241dabb9d99109ebb64acba0124e43150628$
+//
+
+extern (C):
+
+
+
+///
+// Callback structure used for asynchronous continuation of
+// cef_extension_handler_t::GetExtensionResource.
+///
+struct cef_get_extension_resource_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Continue the request. Read the resource contents from |stream|.
+    ///
+    extern(System) void function (
+        cef_get_extension_resource_callback_t* self,
+        cef_stream_reader_t* stream) nothrow cont;
+
+    ///
+    // Cancel the request.
+    ///
+    extern(System) void function (cef_get_extension_resource_callback_t* self) nothrow cancel;
+}
+
+
+
+///
+// Implement this structure to handle events related to browser extensions. The
+// functions of this structure will be called on the UI thread. See
+// cef_request_context_t::LoadExtension for information about extension loading.
+///
+struct cef_extension_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called if the cef_request_context_t::LoadExtension request fails. |result|
+    // will be the error code.
+    ///
+    extern(System) void function (
+        cef_extension_handler_t* self,
+        cef_errorcode_t result) nothrow on_extension_load_failed;
+
+    ///
+    // Called if the cef_request_context_t::LoadExtension request succeeds.
+    // |extension| is the loaded extension.
+    ///
+    extern(System) void function (
+        cef_extension_handler_t* self,
+        cef_extension_t* extension) nothrow on_extension_loaded;
+
+    ///
+    // Called after the cef_extension_t::Unload request has completed.
+    ///
+    extern(System) void function (
+        cef_extension_handler_t* self,
+        cef_extension_t* extension) nothrow on_extension_unloaded;
+
+    ///
+    // Called when an extension needs a browser to host a background script
+    // specified via the "background" manifest key. The browser will have no
+    // visible window and cannot be displayed. |extension| is the extension that
+    // is loading the background script. |url| is an internally generated
+    // reference to an HTML page that will be used to load the background script
+    // via a <script> src attribute. To allow creation of the browser optionally
+    // modify |client| and |settings| and return false (0). To cancel creation of
+    // the browser (and consequently cancel load of the background script) return
+    // true (1). Successful creation will be indicated by a call to
+    // cef_life_span_handler_t::OnAfterCreated, and
+    // cef_browser_host_t::IsBackgroundHost will return true (1) for the resulting
+    // browser. See https://developer.chrome.com/extensions/event_pages for more
+    // information about extension background script usage.
+    ///
+    extern(System) int function (
+        cef_extension_handler_t* self,
+        cef_extension_t* extension,
+        const(cef_string_t)* url,
+        cef_client_t** client,
+        cef_browser_settings_t* settings) nothrow on_before_background_browser;
+
+    ///
+    // Called when an extension API (e.g. chrome.tabs.create) requests creation of
+    // a new browser. |extension| and |browser| are the source of the API call.
+    // |active_browser| may optionally be specified via the windowId property or
+    // returned via the get_active_browser() callback and provides the default
+    // |client| and |settings| values for the new browser. |index| is the position
+    // value optionally specified via the index property. |url| is the URL that
+    // will be loaded in the browser. |active| is true (1) if the new browser
+    // should be active when opened.  To allow creation of the browser optionally
+    // modify |windowInfo|, |client| and |settings| and return false (0). To
+    // cancel creation of the browser return true (1). Successful creation will be
+    // indicated by a call to cef_life_span_handler_t::OnAfterCreated. Any
+    // modifications to |windowInfo| will be ignored if |active_browser| is
+    // wrapped in a cef_browser_view_t.
+    ///
+    extern(System) int function (
+        cef_extension_handler_t* self,
+        cef_extension_t* extension,
+        cef_browser_t* browser,
+        cef_browser_t* active_browser,
+        int index,
+        const(cef_string_t)* url,
+        int active,
+        cef_window_info_t* windowInfo,
+        cef_client_t** client,
+        cef_browser_settings_t* settings) nothrow on_before_browser;
+
+    ///
+    // Called when no tabId is specified to an extension API call that accepts a
+    // tabId parameter (e.g. chrome.tabs.*). |extension| and |browser| are the
+    // source of the API call. Return the browser that will be acted on by the API
+    // call or return NULL to act on |browser|. The returned browser must share
+    // the same cef_request_context_t as |browser|. Incognito browsers should not
+    // be considered unless the source extension has incognito access enabled, in
+    // which case |include_incognito| will be true (1).
+    ///
+    extern(System) cef_browser_t* function (
+        cef_extension_handler_t* self,
+        cef_extension_t* extension,
+        cef_browser_t* browser,
+        int include_incognito) nothrow get_active_browser;
+
+    ///
+    // Called when the tabId associated with |target_browser| is specified to an
+    // extension API call that accepts a tabId parameter (e.g. chrome.tabs.*).
+    // |extension| and |browser| are the source of the API call. Return true (1)
+    // to allow access of false (0) to deny access. Access to incognito browsers
+    // should not be allowed unless the source extension has incognito access
+    // enabled, in which case |include_incognito| will be true (1).
+    ///
+    extern(System) int function (
+        cef_extension_handler_t* self,
+        cef_extension_t* extension,
+        cef_browser_t* browser,
+        int include_incognito,
+        cef_browser_t* target_browser) nothrow can_access_browser;
+
+    ///
+    // Called to retrieve an extension resource that would normally be loaded from
+    // disk (e.g. if a file parameter is specified to chrome.tabs.executeScript).
+    // |extension| and |browser| are the source of the resource request. |file| is
+    // the requested relative file path. To handle the resource request return
+    // true (1) and execute |callback| either synchronously or asynchronously. For
+    // the default behavior which reads the resource from the extension directory
+    // on disk return false (0). Localization substitutions will not be applied to
+    // resources handled via this function.
+    ///
+    extern(System) int function (
+        cef_extension_handler_t* self,
+        cef_extension_t* extension,
+        cef_browser_t* browser,
+        const(cef_string_t)* file,
+        cef_get_extension_resource_callback_t* callback) nothrow get_extension_resource;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_EXTENSION_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=00d75d4f1968686cec7db84a59df89d98d8fe146$
+//
+
+extern (C):
+
+///
+// Creates a directory and all parent directories if they don't already exist.
+// Returns true (1) on successful creation or if the directory already exists.
+// The directory is only readable by the current user. Calling this function on
+// the browser process UI or IO threads is not allowed.
+///
+int cef_create_directory (const(cef_string_t)* full_path);
+
+///
+// Get the temporary directory provided by the system.
+//
+// WARNING: In general, you should use the temp directory variants below instead
+// of this function. Those variants will ensure that the proper permissions are
+// set so that other users on the system can't edit them while they're open
+// (which could lead to security issues).
+///
+int cef_get_temp_directory (cef_string_t* temp_dir);
+
+///
+// Creates a new directory. On Windows if |prefix| is provided the new directory
+// name is in the format of "prefixyyyy". Returns true (1) on success and sets
+// |new_temp_path| to the full path of the directory that was created. The
+// directory is only readable by the current user. Calling this function on the
+// browser process UI or IO threads is not allowed.
+///
+int cef_create_new_temp_directory (
+    const(cef_string_t)* prefix,
+    cef_string_t* new_temp_path);
+
+///
+// Creates a directory within another directory. Extra characters will be
+// appended to |prefix| to ensure that the new directory does not have the same
+// name as an existing directory. Returns true (1) on success and sets |new_dir|
+// to the full path of the directory that was created. The directory is only
+// readable by the current user. Calling this function on the browser process UI
+// or IO threads is not allowed.
+///
+int cef_create_temp_directory_in_directory (
+    const(cef_string_t)* base_dir,
+    const(cef_string_t)* prefix,
+    cef_string_t* new_dir);
+
+///
+// Returns true (1) if the given path exists and is a directory. Calling this
+// function on the browser process UI or IO threads is not allowed.
+///
+int cef_directory_exists (const(cef_string_t)* path);
+
+///
+// Deletes the given path whether it's a file or a directory. If |path| is a
+// directory all contents will be deleted.  If |recursive| is true (1) any sub-
+// directories and their contents will also be deleted (equivalent to executing
+// "rm -rf", so use with caution). On POSIX environments if |path| is a symbolic
+// link then only the symlink will be deleted. Returns true (1) on successful
+// deletion or if |path| does not exist. Calling this function on the browser
+// process UI or IO threads is not allowed.
+///
+int cef_delete_file (const(cef_string_t)* path, int recursive);
+
+///
+// Writes the contents of |src_dir| into a zip archive at |dest_file|. If
+// |include_hidden_files| is true (1) files starting with "." will be included.
+// Returns true (1) on success.  Calling this function on the browser process UI
+// or IO threads is not allowed.
+///
+int cef_zip_directory (
+    const(cef_string_t)* src_dir,
+    const(cef_string_t)* dest_file,
+    int include_hidden_files);
+
+///
+// Loads the existing "Certificate Revocation Lists" file that is managed by
+// Google Chrome. This file can generally be found in Chrome's User Data
+// directory (e.g. "C:\Users\[User]\AppData\Local\Google\Chrome\User Data\" on
+// Windows) and is updated periodically by Chrome's component updater service.
+// Must be called in the browser process after the context has been initialized.
+// See https://dev.chromium.org/Home/chromium-security/crlsets for background.
+///
+void cef_load_crlsets_file (const(cef_string_t)* path);
+
+// CEF_INCLUDE_CAPI_CEF_FILE_UTIL_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=03bb69a14868a95abf3bf7b1608dc351480e307f$
+//
+
+extern (C):
+
+///
+// Implement this structure to handle events related to find results. The
+// functions of this structure will be called on the UI thread.
+///
+struct cef_find_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called to report find results returned by cef_browser_host_t::find().
+    // |identifer| is the identifier passed to find(), |count| is the number of
+    // matches currently identified, |selectionRect| is the location of where the
+    // match was found (in window coordinates), |activeMatchOrdinal| is the
+    // current position in the search results, and |finalUpdate| is true (1) if
+    // this is the last find notification.
+    ///
+    extern(System) void function (
+        cef_find_handler_t* self,
+        cef_browser_t* browser,
+        int identifier,
+        int count,
+        const(cef_rect_t)* selectionRect,
+        int activeMatchOrdinal,
+        int finalUpdate) nothrow on_find_result;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_FIND_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=0fccb41381e922e9d9545ae45ba3e6cf1916c4b0$
+//
+
+extern (C):
+
+///
+// Implement this structure to handle events related to focus. The functions of
+// this structure will be called on the UI thread.
+///
+struct cef_focus_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called when the browser component is about to loose focus. For instance, if
+    // focus was on the last HTML element and the user pressed the TAB key. |next|
+    // will be true (1) if the browser is giving focus to the next component and
+    // false (0) if the browser is giving focus to the previous component.
+    ///
+    extern(System) void function (
+        cef_focus_handler_t* self,
+        cef_browser_t* browser,
+        int next) nothrow on_take_focus;
+
+    ///
+    // Called when the browser component is requesting focus. |source| indicates
+    // where the focus request is originating from. Return false (0) to allow the
+    // focus to be set or true (1) to cancel setting the focus.
+    ///
+    extern(System) int function (
+        cef_focus_handler_t* self,
+        cef_browser_t* browser,
+        cef_focus_source_t source) nothrow on_set_focus;
+
+    ///
+    // Called when the browser component has received focus.
+    ///
+    extern(System) void function (
+        cef_focus_handler_t* self,
+        cef_browser_t* browser) nothrow on_got_focus;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_FOCUS_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=872fd1e811d41f56f03da0da75a8f2e89cad40cd$
+//
+
+extern (C):
+
+
+
+
+
+
+///
+// Structure used to represent a frame in the browser window. When used in the
+// browser process the functions of this structure may be called on any thread
+// unless otherwise indicated in the comments. When used in the render process
+// the functions of this structure may only be called on the main thread.
+///
+struct cef_frame_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // True if this object is currently attached to a valid frame.
+    ///
+    extern(System) int function (cef_frame_t* self) nothrow is_valid;
+
+    ///
+    // Execute undo in this frame.
+    ///
+    extern(System) void function (cef_frame_t* self) nothrow undo;
+
+    ///
+    // Execute redo in this frame.
+    ///
+    extern(System) void function (cef_frame_t* self) nothrow redo;
+
+    ///
+    // Execute cut in this frame.
+    ///
+    extern(System) void function (cef_frame_t* self) nothrow cut;
+
+    ///
+    // Execute copy in this frame.
+    ///
+    extern(System) void function (cef_frame_t* self) nothrow copy;
+
+    ///
+    // Execute paste in this frame.
+    ///
+    extern(System) void function (cef_frame_t* self) nothrow paste;
+
+    ///
+    // Execute delete in this frame.
+    ///
+    extern(System) void function (cef_frame_t* self) nothrow del;
+
+    ///
+    // Execute select all in this frame.
+    ///
+    extern(System) void function (cef_frame_t* self) nothrow select_all;
+
+    ///
+    // Save this frame's HTML source to a temporary file and open it in the
+    // default text viewing application. This function can only be called from the
+    // browser process.
+    ///
+    extern(System) void function (cef_frame_t* self) nothrow view_source;
+
+    ///
+    // Retrieve this frame's HTML source as a string sent to the specified
+    // visitor.
+    ///
+    extern(System) void function (
+        cef_frame_t* self,
+        cef_string_visitor_t* visitor) nothrow get_source;
+
+    ///
+    // Retrieve this frame's display text as a string sent to the specified
+    // visitor.
+    ///
+    extern(System) void function (
+        cef_frame_t* self,
+        cef_string_visitor_t* visitor) nothrow get_text;
+
+    ///
+    // Load the request represented by the |request| object.
+    //
+    // WARNING: This function will fail with "bad IPC message" reason
+    // INVALID_INITIATOR_ORIGIN (213) unless you first navigate to the request
+    // origin using some other mechanism (LoadURL, link click, etc).
+    ///
+    extern(System) void function (cef_frame_t* self, cef_request_t* request) nothrow load_request;
+
+    ///
+    // Load the specified |url|.
+    ///
+    extern(System) void function (cef_frame_t* self, const(cef_string_t)* url) nothrow load_url;
+
+    ///
+    // Execute a string of JavaScript code in this frame. The |script_url|
+    // parameter is the URL where the script in question can be found, if any. The
+    // renderer may request this URL to show the developer the source of the
+    // error.  The |start_line| parameter is the base line number to use for error
+    // reporting.
+    ///
+    extern(System) void function (
+        cef_frame_t* self,
+        const(cef_string_t)* code,
+        const(cef_string_t)* script_url,
+        int start_line) nothrow execute_java_script;
+
+    ///
+    // Returns true (1) if this is the main (top-level) frame.
+    ///
+    extern(System) int function (cef_frame_t* self) nothrow is_main;
+
+    ///
+    // Returns true (1) if this is the focused frame.
+    ///
+    extern(System) int function (cef_frame_t* self) nothrow is_focused;
+
+    ///
+    // Returns the name for this frame. If the frame has an assigned name (for
+    // example, set via the iframe "name" attribute) then that value will be
+    // returned. Otherwise a unique name will be constructed based on the frame
+    // parent hierarchy. The main (top-level) frame will always have an NULL name
+    // value.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_frame_t* self) nothrow get_name;
+
+    ///
+    // Returns the globally unique identifier for this frame or < 0 if the
+    // underlying frame does not yet exist.
+    ///
+    extern(System) int64 function (cef_frame_t* self) nothrow get_identifier;
+
+    ///
+    // Returns the parent of this frame or NULL if this is the main (top-level)
+    // frame.
+    ///
+    extern(System) cef_frame_t* function (cef_frame_t* self) nothrow get_parent;
+
+    ///
+    // Returns the URL currently loaded in this frame.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_frame_t* self) nothrow get_url;
+
+    ///
+    // Returns the browser that this frame belongs to.
+    ///
+    extern(System) cef_browser_t* function (cef_frame_t* self) nothrow get_browser;
+
+    ///
+    // Get the V8 context associated with the frame. This function can only be
+    // called from the render process.
+    ///
+    extern(System) cef_v8context_t* function (cef_frame_t* self) nothrow get_v8context;
+
+    ///
+    // Visit the DOM document. This function can only be called from the render
+    // process.
+    ///
+    extern(System) void function (cef_frame_t* self, cef_domvisitor_t* visitor) nothrow visit_dom;
+
+    ///
+    // Create a new URL request that will be treated as originating from this
+    // frame and the associated browser. This request may be intercepted by the
+    // client via cef_resource_request_handler_t or cef_scheme_handler_factory_t.
+    // Use cef_urlrequest_t::Create instead if you do not want the request to have
+    // this association, in which case it may be handled differently (see
+    // documentation on that function). Requests may originate from both the
+    // browser process and the render process.
+    //
+    // For requests originating from the browser process:
+    //   - POST data may only contain a single element of type PDE_TYPE_FILE or
+    //     PDE_TYPE_BYTES.
+    // For requests originating from the render process:
+    //   - POST data may only contain a single element of type PDE_TYPE_BYTES.
+    //   - If the response contains Content-Disposition or Mime-Type header values
+    //     that would not normally be rendered then the response may receive
+    //     special handling inside the browser (for example, via the file download
+    //     code path instead of the URL request code path).
+    //
+    // The |request| object will be marked as read-only after calling this
+    // function.
+    ///
+    extern(System) cef_urlrequest_t* function (
+        cef_frame_t* self,
+        cef_request_t* request,
+        cef_urlrequest_client_t* client) nothrow create_urlrequest;
+
+    ///
+    // Send a message to the specified |target_process|. Ownership of the message
+    // contents will be transferred and the |message| reference will be
+    // invalidated. Message delivery is not guaranteed in all cases (for example,
+    // if the browser is closing, navigating, or if the target process crashes).
+    // Send an ACK message back from the target process if confirmation is
+    // required.
+    ///
+    extern(System) void function (
+        cef_frame_t* self,
+        cef_process_id_t target_process,
+        cef_process_message_t* message) nothrow send_process_message;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_FRAME_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=f6be5f7509ee3ccfe16f226470897223cc131014$
+//
+
+extern (C):
+
+///
+// Implement this structure to handle events related to cef_frame_t life span.
+// The order of callbacks is:
+//
+// (1) During initial cef_browser_host_t creation and navigation of the main
+// frame: - cef_frame_handler_t::OnFrameCreated => The initial main frame object
+// has been
+//   created. Any commands will be queued until the frame is attached.
+// - cef_frame_handler_t::OnMainFrameChanged => The initial main frame object
+// has
+//   been assigned to the browser.
+// - cef_life_span_handler_t::OnAfterCreated => The browser is now valid and can
+// be
+//   used.
+// - cef_frame_handler_t::OnFrameAttached => The initial main frame object is
+// now
+//   connected to its peer in the renderer process. Commands can be routed.
+//
+// (2) During further cef_browser_host_t navigation/loading of the main frame
+// and/or sub-frames: - cef_frame_handler_t::OnFrameCreated => A new main frame
+// or sub-frame object has
+//   been created. Any commands will be queued until the frame is attached.
+// - cef_frame_handler_t::OnFrameAttached => A new main frame or sub-frame
+// object is
+//   now connected to its peer in the renderer process. Commands can be routed.
+// - cef_frame_handler_t::OnFrameDetached => An existing main frame or sub-frame
+//   object has lost its connection to the renderer process. If multiple objects
+//   are detached at the same time then notifications will be sent for any
+//   sub-frame objects before the main frame object. Commands can no longer be
+//   routed and will be discarded.
+// - cef_frame_handler_t::OnMainFrameChanged => A new main frame object has been
+//   assigned to the browser. This will only occur with cross-origin navigation
+//   or re-navigation after renderer process termination (due to crashes, etc).
+//
+// (3) During final cef_browser_host_t destruction of the main frame: -
+// cef_frame_handler_t::OnFrameDetached => Any sub-frame objects have lost their
+//   connection to the renderer process. Commands can no longer be routed and
+//   will be discarded.
+// - cef_life_span_handler_t::OnBeforeClose => The browser has been destroyed. -
+// cef_frame_handler_t::OnFrameDetached => The main frame object have lost its
+//   connection to the renderer process. Notifications will be sent for any
+//   sub-frame objects before the main frame object. Commands can no longer be
+//   routed and will be discarded.
+// - cef_frame_handler_t::OnMainFrameChanged => The final main frame object has
+// been
+//   removed from the browser.
+//
+// Cross-origin navigation and/or loading receives special handling.
+//
+// When the main frame navigates to a different origin the OnMainFrameChanged
+// callback (2) will be executed with the old and new main frame objects.
+//
+// When a new sub-frame is loaded in, or an existing sub-frame is navigated to,
+// a different origin from the parent frame, a temporary sub-frame object will
+// first be created in the parent's renderer process. That temporary sub-frame
+// will then be discarded after the real cross-origin sub-frame is created in
+// the new/target renderer process. The client will receive cross-origin
+// navigation callbacks (2) for the transition from the temporary sub-frame to
+// the real sub-frame. The temporary sub-frame will not recieve or execute
+// commands during this transitional period (any sent commands will be
+// discarded).
+//
+// When a new popup browser is created in a different origin from the parent
+// browser, a temporary main frame object for the popup will first be created in
+// the parent's renderer process. That temporary main frame will then be
+// discarded after the real cross-origin main frame is created in the new/target
+// renderer process. The client will recieve creation and initial navigation
+// callbacks (1) for the temporary main frame, followed by cross-origin
+// navigation callbacks (2) for the transition from the temporary main frame to
+// the real main frame. The temporary main frame may receive and execute
+// commands during this transitional period (any sent commands may be executed,
+// but the behavior is potentially undesirable since they execute in the parent
+// browser's renderer process and not the new/target renderer process).
+//
+// Callbacks will not be executed for placeholders that may be created during
+// pre-commit navigation for sub-frames that do not yet exist in the renderer
+// process. Placeholders will have cef_frame_t::get_identifier() == -4.
+//
+// The functions of this structure will be called on the UI thread unless
+// otherwise indicated.
+///
+struct cef_frame_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called when a new frame is created. This will be the first notification
+    // that references |frame|. Any commands that require transport to the
+    // associated renderer process (LoadRequest, SendProcessMessage, GetSource,
+    // etc.) will be queued until OnFrameAttached is called for |frame|.
+    ///
+    extern(System) void function (
+        cef_frame_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame) nothrow on_frame_created;
+
+    ///
+    // Called when a frame can begin routing commands to/from the associated
+    // renderer process. |reattached| will be true (1) if the frame was re-
+    // attached after exiting the BackForwardCache. Any commands that were queued
+    // have now been dispatched.
+    ///
+    extern(System) void function (
+        cef_frame_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        int reattached) nothrow on_frame_attached;
+
+    ///
+    // Called when a frame loses its connection to the renderer process and will
+    // be destroyed. Any pending or future commands will be discarded and
+    // cef_frame_t::is_valid() will now return false (0) for |frame|. If called
+    // after cef_life_span_handler_t::on_before_close() during browser destruction
+    // then cef_browser_t::is_valid() will return false (0) for |browser|.
+    ///
+    extern(System) void function (
+        cef_frame_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame) nothrow on_frame_detached;
+
+    ///
+    // Called when the main frame changes due to (a) initial browser creation, (b)
+    // final browser destruction, (c) cross-origin navigation or (d) re-navigation
+    // after renderer process termination (due to crashes, etc). |old_frame| will
+    // be NULL and |new_frame| will be non-NULL when a main frame is assigned to
+    // |browser| for the first time. |old_frame| will be non-NULL and |new_frame|
+    // will be NULL and  when a main frame is removed from |browser| for the last
+    // time. Both |old_frame| and |new_frame| will be non-NULL for cross-origin
+    // navigations or re-navigation after renderer process termination. This
+    // function will be called after on_frame_created() for |new_frame| and/or
+    // after on_frame_detached() for |old_frame|. If called after
+    // cef_life_span_handler_t::on_before_close() during browser destruction then
+    // cef_browser_t::is_valid() will return false (0) for |browser|.
+    ///
+    extern(System) void function (
+        cef_frame_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* old_frame,
+        cef_frame_t* new_frame) nothrow on_main_frame_changed;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_FRAME_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=bf890f7b8e8edd423d71ad5a4d5bd43d81f1eb01$
+//
+
+extern (C):
+
+///
+// Returns true (1) if the application text direction is right-to-left.
+///
+int cef_is_rtl ();
+
+// CEF_INCLUDE_CAPI_CEF_I18N_UTIL_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=d9da8862142742e780086714bbd4fb44ac95cf2c$
+//
+
+extern (C):
+
+///
+// Container for a single image represented at different scale factors. All
+// image representations should be the same size in density independent pixel
+// (DIP) units. For example, if the image at scale factor 1.0 is 100x100 pixels
+// then the image at scale factor 2.0 should be 200x200 pixels -- both images
+// will display with a DIP size of 100x100 units. The functions of this
+// structure can be called on any browser process thread.
+///
+struct cef_image_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this Image is NULL.
+    ///
+    extern(System) int function (cef_image_t* self) nothrow is_empty;
+
+    ///
+    // Returns true (1) if this Image and |that| Image share the same underlying
+    // storage. Will also return true (1) if both images are NULL.
+    ///
+    extern(System) int function (cef_image_t* self, cef_image_t* that) nothrow is_same;
+
+    ///
+    // Add a bitmap image representation for |scale_factor|. Only 32-bit RGBA/BGRA
+    // formats are supported. |pixel_width| and |pixel_height| are the bitmap
+    // representation size in pixel coordinates. |pixel_data| is the array of
+    // pixel data and should be |pixel_width| x |pixel_height| x 4 bytes in size.
+    // |color_type| and |alpha_type| values specify the pixel format.
+    ///
+    extern(System) int function (
+        cef_image_t* self,
+        float scale_factor,
+        int pixel_width,
+        int pixel_height,
+        cef_color_type_t color_type,
+        cef_alpha_type_t alpha_type,
+        const(void)* pixel_data,
+        size_t pixel_data_size) nothrow add_bitmap;
+
+    ///
+    // Add a PNG image representation for |scale_factor|. |png_data| is the image
+    // data of size |png_data_size|. Any alpha transparency in the PNG data will
+    // be maintained.
+    ///
+    extern(System) int function (
+        cef_image_t* self,
+        float scale_factor,
+        const(void)* png_data,
+        size_t png_data_size) nothrow add_png;
+
+    ///
+    // Create a JPEG image representation for |scale_factor|. |jpeg_data| is the
+    // image data of size |jpeg_data_size|. The JPEG format does not support
+    // transparency so the alpha byte will be set to 0xFF for all pixels.
+    ///
+    extern(System) int function (
+        cef_image_t* self,
+        float scale_factor,
+        const(void)* jpeg_data,
+        size_t jpeg_data_size) nothrow add_jpeg;
+
+    ///
+    // Returns the image width in density independent pixel (DIP) units.
+    ///
+    extern(System) size_t function (cef_image_t* self) nothrow get_width;
+
+    ///
+    // Returns the image height in density independent pixel (DIP) units.
+    ///
+    extern(System) size_t function (cef_image_t* self) nothrow get_height;
+
+    ///
+    // Returns true (1) if this image contains a representation for
+    // |scale_factor|.
+    ///
+    extern(System) int function (cef_image_t* self, float scale_factor) nothrow has_representation;
+
+    ///
+    // Removes the representation for |scale_factor|. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_image_t* self,
+        float scale_factor) nothrow remove_representation;
+
+    ///
+    // Returns information for the representation that most closely matches
+    // |scale_factor|. |actual_scale_factor| is the actual scale factor for the
+    // representation. |pixel_width| and |pixel_height| are the representation
+    // size in pixel coordinates. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_image_t* self,
+        float scale_factor,
+        float* actual_scale_factor,
+        int* pixel_width,
+        int* pixel_height) nothrow get_representation_info;
+
+    ///
+    // Returns the bitmap representation that most closely matches |scale_factor|.
+    // Only 32-bit RGBA/BGRA formats are supported. |color_type| and |alpha_type|
+    // values specify the desired output pixel format. |pixel_width| and
+    // |pixel_height| are the output representation size in pixel coordinates.
+    // Returns a cef_binary_value_t containing the pixel data on success or NULL
+    // on failure.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_image_t* self,
+        float scale_factor,
+        cef_color_type_t color_type,
+        cef_alpha_type_t alpha_type,
+        int* pixel_width,
+        int* pixel_height) nothrow get_as_bitmap;
+
+    ///
+    // Returns the PNG representation that most closely matches |scale_factor|. If
+    // |with_transparency| is true (1) any alpha transparency in the image will be
+    // represented in the resulting PNG data. |pixel_width| and |pixel_height| are
+    // the output representation size in pixel coordinates. Returns a
+    // cef_binary_value_t containing the PNG image data on success or NULL on
+    // failure.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_image_t* self,
+        float scale_factor,
+        int with_transparency,
+        int* pixel_width,
+        int* pixel_height) nothrow get_as_png;
+
+    ///
+    // Returns the JPEG representation that most closely matches |scale_factor|.
+    // |quality| determines the compression level with 0 == lowest and 100 ==
+    // highest. The JPEG format does not support alpha transparency and the alpha
+    // channel, if any, will be discarded. |pixel_width| and |pixel_height| are
+    // the output representation size in pixel coordinates. Returns a
+    // cef_binary_value_t containing the JPEG image data on success or NULL on
+    // failure.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_image_t* self,
+        float scale_factor,
+        int quality,
+        int* pixel_width,
+        int* pixel_height) nothrow get_as_jpeg;
+}
+
+
+
+///
+// Create a new cef_image_t. It will initially be NULL. Use the Add*() functions
+// to add representations at different scale factors.
+///
+cef_image_t* cef_image_create ();
+
+// CEF_INCLUDE_CAPI_CEF_IMAGE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=d991e2a7d1a58a013e4d3a963361fed6918f4ec3$
+//
+
+extern (C):
+
+///
+// Callback structure used for asynchronous continuation of JavaScript dialog
+// requests.
+///
+struct cef_jsdialog_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Continue the JS dialog request. Set |success| to true (1) if the OK button
+    // was pressed. The |user_input| value should be specified for prompt dialogs.
+    ///
+    extern(System) void function (
+        cef_jsdialog_callback_t* self,
+        int success,
+        const(cef_string_t)* user_input) nothrow cont;
+}
+
+
+
+///
+// Implement this structure to handle events related to JavaScript dialogs. The
+// functions of this structure will be called on the UI thread.
+///
+struct cef_jsdialog_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called to run a JavaScript dialog. If |origin_url| is non-NULL it can be
+    // passed to the CefFormatUrlForSecurityDisplay function to retrieve a secure
+    // and user-friendly display string. The |default_prompt_text| value will be
+    // specified for prompt dialogs only. Set |suppress_message| to true (1) and
+    // return false (0) to suppress the message (suppressing messages is
+    // preferable to immediately executing the callback as this is used to detect
+    // presumably malicious behavior like spamming alert messages in
+    // onbeforeunload). Set |suppress_message| to false (0) and return false (0)
+    // to use the default implementation (the default implementation will show one
+    // modal dialog at a time and suppress any additional dialog requests until
+    // the displayed dialog is dismissed). Return true (1) if the application will
+    // use a custom dialog or if the callback has been executed immediately.
+    // Custom dialogs may be either modal or modeless. If a custom dialog is used
+    // the application must execute |callback| once the custom dialog is
+    // dismissed.
+    ///
+    extern(System) int function (
+        cef_jsdialog_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* origin_url,
+        cef_jsdialog_type_t dialog_type,
+        const(cef_string_t)* message_text,
+        const(cef_string_t)* default_prompt_text,
+        cef_jsdialog_callback_t* callback,
+        int* suppress_message) nothrow on_jsdialog;
+
+    ///
+    // Called to run a dialog asking the user if they want to leave a page. Return
+    // false (0) to use the default dialog implementation. Return true (1) if the
+    // application will use a custom dialog or if the callback has been executed
+    // immediately. Custom dialogs may be either modal or modeless. If a custom
+    // dialog is used the application must execute |callback| once the custom
+    // dialog is dismissed.
+    ///
+    extern(System) int function (
+        cef_jsdialog_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* message_text,
+        int is_reload,
+        cef_jsdialog_callback_t* callback) nothrow on_before_unload_dialog;
+
+    ///
+    // Called to cancel any pending dialogs and reset any saved dialog state. Will
+    // be called due to events like page navigation irregardless of whether any
+    // dialogs are currently pending.
+    ///
+    extern(System) void function (
+        cef_jsdialog_handler_t* self,
+        cef_browser_t* browser) nothrow on_reset_dialog_state;
+
+    ///
+    // Called when the default implementation dialog is closed.
+    ///
+    extern(System) void function (
+        cef_jsdialog_handler_t* self,
+        cef_browser_t* browser) nothrow on_dialog_closed;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_JSDIALOG_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=d804a2db0f9ac13afd249407c85cb8d5852508ac$
+//
+
+extern (C):
+
+///
+// Implement this structure to handle events related to keyboard input. The
+// functions of this structure will be called on the UI thread.
+///
+struct cef_keyboard_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called before a keyboard event is sent to the renderer. |event| contains
+    // information about the keyboard event. |os_event| is the operating system
+    // event message, if any. Return true (1) if the event was handled or false
+    // (0) otherwise. If the event will be handled in on_key_event() as a keyboard
+    // shortcut set |is_keyboard_shortcut| to true (1) and return false (0).
+    ///
+    extern(System) int function (
+        cef_keyboard_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_key_event_t)* event,
+        XEvent* os_event,
+        int* is_keyboard_shortcut) nothrow on_pre_key_event;
+
+    ///
+    // Called after the renderer and JavaScript in the page has had a chance to
+    // handle the event. |event| contains information about the keyboard event.
+    // |os_event| is the operating system event message, if any. Return true (1)
+    // if the keyboard event was handled or false (0) otherwise.
+    ///
+    extern(System) int function (
+        cef_keyboard_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_key_event_t)* event,
+        XEvent* os_event) nothrow on_key_event;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=e44bb89a337942c82bfa246275b4b033821b2782$
+//
+
+extern (C):
+
+
+
+///
+// Implement this structure to handle events related to browser life span. The
+// functions of this structure will be called on the UI thread unless otherwise
+// indicated.
+///
+struct cef_life_span_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called on the UI thread before a new popup browser is created. The
+    // |browser| and |frame| values represent the source of the popup request. The
+    // |target_url| and |target_frame_name| values indicate where the popup
+    // browser should navigate and may be NULL if not specified with the request.
+    // The |target_disposition| value indicates where the user intended to open
+    // the popup (e.g. current tab, new tab, etc). The |user_gesture| value will
+    // be true (1) if the popup was opened via explicit user gesture (e.g.
+    // clicking a link) or false (0) if the popup opened automatically (e.g. via
+    // the DomContentLoaded event). The |popupFeatures| structure contains
+    // additional information about the requested popup window. To allow creation
+    // of the popup browser optionally modify |windowInfo|, |client|, |settings|
+    // and |no_javascript_access| and return false (0). To cancel creation of the
+    // popup browser return true (1). The |client| and |settings| values will
+    // default to the source browser's values. If the |no_javascript_access| value
+    // is set to false (0) the new browser will not be scriptable and may not be
+    // hosted in the same renderer process as the source browser. Any
+    // modifications to |windowInfo| will be ignored if the parent browser is
+    // wrapped in a cef_browser_view_t. Popup browser creation will be canceled if
+    // the parent browser is destroyed before the popup browser creation completes
+    // (indicated by a call to OnAfterCreated for the popup browser). The
+    // |extra_info| parameter provides an opportunity to specify extra information
+    // specific to the created popup browser that will be passed to
+    // cef_render_process_handler_t::on_browser_created() in the render process.
+    ///
+    extern(System) int function (
+        cef_life_span_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        const(cef_string_t)* target_url,
+        const(cef_string_t)* target_frame_name,
+        cef_window_open_disposition_t target_disposition,
+        int user_gesture,
+        const(cef_popup_features_t)* popupFeatures,
+        cef_window_info_t* windowInfo,
+        cef_client_t** client,
+        cef_browser_settings_t* settings,
+        cef_dictionary_value_t** extra_info,
+        int* no_javascript_access) nothrow on_before_popup;
+
+    ///
+    // Called after a new browser is created. It is now safe to begin performing
+    // actions with |browser|. cef_frame_handler_t callbacks related to initial
+    // main frame creation will arrive before this callback. See
+    // cef_frame_handler_t documentation for additional usage information.
+    ///
+    extern(System) void function (
+        cef_life_span_handler_t* self,
+        cef_browser_t* browser) nothrow on_after_created;
+
+    ///
+    // Called when a browser has recieved a request to close. This may result
+    // directly from a call to cef_browser_host_t::*close_browser() or indirectly
+    // if the browser is parented to a top-level window created by CEF and the
+    // user attempts to close that window (by clicking the 'X', for example). The
+    // do_close() function will be called after the JavaScript 'onunload' event
+    // has been fired.
+    //
+    // An application should handle top-level owner window close notifications by
+    // calling cef_browser_host_t::try_close_browser() or
+    // cef_browser_host_t::CloseBrowser(false (0)) instead of allowing the window
+    // to close immediately (see the examples below). This gives CEF an
+    // opportunity to process the 'onbeforeunload' event and optionally cancel the
+    // close before do_close() is called.
+    //
+    // When windowed rendering is enabled CEF will internally create a window or
+    // view to host the browser. In that case returning false (0) from do_close()
+    // will send the standard close notification to the browser's top-level owner
+    // window (e.g. WM_CLOSE on Windows, performClose: on OS X, "delete_event" on
+    // Linux or cef_window_delegate_t::can_close() callback from Views). If the
+    // browser's host window/view has already been destroyed (via view hierarchy
+    // tear-down, for example) then do_close() will not be called for that browser
+    // since is no longer possible to cancel the close.
+    //
+    // When windowed rendering is disabled returning false (0) from do_close()
+    // will cause the browser object to be destroyed immediately.
+    //
+    // If the browser's top-level owner window requires a non-standard close
+    // notification then send that notification from do_close() and return true
+    // (1).
+    //
+    // The cef_life_span_handler_t::on_before_close() function will be called
+    // after do_close() (if do_close() is called) and immediately before the
+    // browser object is destroyed. The application should only exit after
+    // on_before_close() has been called for all existing browsers.
+    //
+    // The below examples describe what should happen during window close when the
+    // browser is parented to an application-provided top-level window.
+    //
+    // Example 1: Using cef_browser_host_t::try_close_browser(). This is
+    // recommended for clients using standard close handling and windows created
+    // on the browser process UI thread. 1.  User clicks the window close button
+    // which sends a close notification to
+    //     the application's top-level window.
+    // 2.  Application's top-level window receives the close notification and
+    //     calls TryCloseBrowser() (which internally calls CloseBrowser(false)).
+    //     TryCloseBrowser() returns false so the client cancels the window close.
+    // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+    //     confirmation dialog (which can be overridden via
+    //     CefJSDialogHandler::OnBeforeUnloadDialog()).
+    // 4.  User approves the close. 5.  JavaScript 'onunload' handler executes. 6.
+    // CEF sends a close notification to the application's top-level window
+    //     (because DoClose() returned false by default).
+    // 7.  Application's top-level window receives the close notification and
+    //     calls TryCloseBrowser(). TryCloseBrowser() returns true so the client
+    //     allows the window close.
+    // 8.  Application's top-level window is destroyed. 9.  Application's
+    // on_before_close() handler is called and the browser object
+    //     is destroyed.
+    // 10. Application exits by calling cef_quit_message_loop() if no other
+    // browsers
+    //     exist.
+    //
+    // Example 2: Using cef_browser_host_t::CloseBrowser(false (0)) and
+    // implementing the do_close() callback. This is recommended for clients using
+    // non-standard close handling or windows that were not created on the browser
+    // process UI thread. 1.  User clicks the window close button which sends a
+    // close notification to
+    //     the application's top-level window.
+    // 2.  Application's top-level window receives the close notification and:
+    //     A. Calls CefBrowserHost::CloseBrowser(false).
+    //     B. Cancels the window close.
+    // 3.  JavaScript 'onbeforeunload' handler executes and shows the close
+    //     confirmation dialog (which can be overridden via
+    //     CefJSDialogHandler::OnBeforeUnloadDialog()).
+    // 4.  User approves the close. 5.  JavaScript 'onunload' handler executes. 6.
+    // Application's do_close() handler is called. Application will:
+    //     A. Set a flag to indicate that the next close attempt will be allowed.
+    //     B. Return false.
+    // 7.  CEF sends an close notification to the application's top-level window.
+    // 8.  Application's top-level window receives the close notification and
+    //     allows the window to close based on the flag from #6B.
+    // 9.  Application's top-level window is destroyed. 10. Application's
+    // on_before_close() handler is called and the browser object
+    //     is destroyed.
+    // 11. Application exits by calling cef_quit_message_loop() if no other
+    // browsers
+    //     exist.
+    ///
+    extern(System) int function (
+        cef_life_span_handler_t* self,
+        cef_browser_t* browser) nothrow do_close;
+
+    ///
+    // Called just before a browser is destroyed. Release all references to the
+    // browser object and do not attempt to execute any functions on the browser
+    // object (other than IsValid, GetIdentifier or IsSame) after this callback
+    // returns. cef_frame_handler_t callbacks related to final main frame
+    // destruction will arrive after this callback and cef_browser_t::IsValid will
+    // return false (0) at that time. Any in-progress network requests associated
+    // with |browser| will be aborted when the browser is destroyed, and
+    // cef_resource_request_handler_t callbacks related to those requests may
+    // still arrive on the IO thread after this callback. See cef_frame_handler_t
+    // and do_close() documentation for additional usage information.
+    ///
+    extern(System) void function (
+        cef_life_span_handler_t* self,
+        cef_browser_t* browser) nothrow on_before_close;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=6c6a719d7cbbc01adfdc9bbe0dff6da10e06e3f3$
+//
+
+extern (C):
+
+///
+// Implement this structure to handle events related to browser load status. The
+// functions of this structure will be called on the browser process UI thread
+// or render process main thread (TID_RENDERER).
+///
+struct cef_load_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called when the loading state has changed. This callback will be executed
+    // twice -- once when loading is initiated either programmatically or by user
+    // action, and once when loading is terminated due to completion, cancellation
+    // of failure. It will be called before any calls to OnLoadStart and after all
+    // calls to OnLoadError and/or OnLoadEnd.
+    ///
+    extern(System) void function (
+        cef_load_handler_t* self,
+        cef_browser_t* browser,
+        int isLoading,
+        int canGoBack,
+        int canGoForward) nothrow on_loading_state_change;
+
+    ///
+    // Called after a navigation has been committed and before the browser begins
+    // loading contents in the frame. The |frame| value will never be NULL -- call
+    // the is_main() function to check if this frame is the main frame.
+    // |transition_type| provides information about the source of the navigation
+    // and an accurate value is only available in the browser process. Multiple
+    // frames may be loading at the same time. Sub-frames may start or continue
+    // loading after the main frame load has ended. This function will not be
+    // called for same page navigations (fragments, history state, etc.) or for
+    // navigations that fail or are canceled before commit. For notification of
+    // overall browser load status use OnLoadingStateChange instead.
+    ///
+    extern(System) void function (
+        cef_load_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_transition_type_t transition_type) nothrow on_load_start;
+
+    ///
+    // Called when the browser is done loading a frame. The |frame| value will
+    // never be NULL -- call the is_main() function to check if this frame is the
+    // main frame. Multiple frames may be loading at the same time. Sub-frames may
+    // start or continue loading after the main frame load has ended. This
+    // function will not be called for same page navigations (fragments, history
+    // state, etc.) or for navigations that fail or are canceled before commit.
+    // For notification of overall browser load status use OnLoadingStateChange
+    // instead.
+    ///
+    extern(System) void function (
+        cef_load_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        int httpStatusCode) nothrow on_load_end;
+
+    ///
+    // Called when a navigation fails or is canceled. This function may be called
+    // by itself if before commit or in combination with OnLoadStart/OnLoadEnd if
+    // after commit. |errorCode| is the error code number, |errorText| is the
+    // error text and |failedUrl| is the URL that failed to load. See
+    // net\base\net_error_list.h for complete descriptions of the error codes.
+    ///
+    extern(System) void function (
+        cef_load_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_errorcode_t errorCode,
+        const(cef_string_t)* errorText,
+        const(cef_string_t)* failedUrl) nothrow on_load_error;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_LOAD_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=79e4e38c732c0cfeef495c8a9726e105054012bb$
+//
+
+extern (C):
+
+///
+// Supports discovery of and communication with media devices on the local
+// network via the Cast and DIAL protocols. The functions of this structure may
+// be called on any browser process thread unless otherwise indicated.
+///
+struct cef_media_router_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Add an observer for MediaRouter events. The observer will remain registered
+    // until the returned Registration object is destroyed.
+    ///
+    extern(System) cef_registration_t* function (
+        cef_media_router_t* self,
+        cef_media_observer_t* observer) nothrow add_observer;
+
+    ///
+    // Returns a MediaSource object for the specified media source URN. Supported
+    // URN schemes include "cast:" and "dial:", and will be already known by the
+    // client application (e.g. "cast:<appId>?clientId=<clientId>").
+    ///
+    extern(System) cef_media_source_t* function (
+        cef_media_router_t* self,
+        const(cef_string_t)* urn) nothrow get_source;
+
+    ///
+    // Trigger an asynchronous call to cef_media_observer_t::OnSinks on all
+    // registered observers.
+    ///
+    extern(System) void function (cef_media_router_t* self) nothrow notify_current_sinks;
+
+    ///
+    // Create a new route between |source| and |sink|. Source and sink must be
+    // valid, compatible (as reported by cef_media_sink_t::IsCompatibleWith), and
+    // a route between them must not already exist. |callback| will be executed on
+    // success or failure. If route creation succeeds it will also trigger an
+    // asynchronous call to cef_media_observer_t::OnRoutes on all registered
+    // observers.
+    ///
+    extern(System) void function (
+        cef_media_router_t* self,
+        cef_media_source_t* source,
+        cef_media_sink_t* sink,
+        cef_media_route_create_callback_t* callback) nothrow create_route;
+
+    ///
+    // Trigger an asynchronous call to cef_media_observer_t::OnRoutes on all
+    // registered observers.
+    ///
+    extern(System) void function (cef_media_router_t* self) nothrow notify_current_routes;
+}
+
+
+
+///
+// Returns the MediaRouter object associated with the global request context. If
+// |callback| is non-NULL it will be executed asnychronously on the UI thread
+// after the manager's storage has been initialized. Equivalent to calling cef_r
+// equest_context_t::cef_request_context_get_global_context()->get_media_router(
+// ).
+///
+cef_media_router_t* cef_media_router_get_global (
+    cef_completion_callback_t* callback);
+
+///
+// Implemented by the client to observe MediaRouter events and registered via
+// cef_media_router_t::AddObserver. The functions of this structure will be
+// called on the browser process UI thread.
+///
+struct cef_media_observer_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // The list of available media sinks has changed or
+    // cef_media_router_t::NotifyCurrentSinks was called.
+    ///
+    extern(System) void function (
+        cef_media_observer_t* self,
+        size_t sinksCount,
+        cef_media_sink_t** sinks) nothrow on_sinks;
+
+    ///
+    // The list of available media routes has changed or
+    // cef_media_router_t::NotifyCurrentRoutes was called.
+    ///
+    extern(System) void function (
+        cef_media_observer_t* self,
+        size_t routesCount,
+        cef_media_route_t** routes) nothrow on_routes;
+
+    ///
+    // The connection state of |route| has changed.
+    ///
+    extern(System) void function (
+        cef_media_observer_t* self,
+        cef_media_route_t* route,
+        cef_media_route_connection_state_t state) nothrow on_route_state_changed;
+
+    ///
+    // A message was recieved over |route|. |message| is only valid for the scope
+    // of this callback and should be copied if necessary.
+    ///
+    extern(System) void function (
+        cef_media_observer_t* self,
+        cef_media_route_t* route,
+        const(void)* message,
+        size_t message_size) nothrow on_route_message_received;
+}
+
+
+
+///
+// Represents the route between a media source and sink. Instances of this
+// object are created via cef_media_router_t::CreateRoute and retrieved via
+// cef_media_observer_t::OnRoutes. Contains the status and metadata of a routing
+// operation. The functions of this structure may be called on any browser
+// process thread unless otherwise indicated.
+///
+struct cef_media_route_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the ID for this route.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_media_route_t* self) nothrow get_id;
+
+    ///
+    // Returns the source associated with this route.
+    ///
+    extern(System) cef_media_source_t* function (cef_media_route_t* self) nothrow get_source;
+
+    ///
+    // Returns the sink associated with this route.
+    ///
+    extern(System) cef_media_sink_t* function (cef_media_route_t* self) nothrow get_sink;
+
+    ///
+    // Send a message over this route. |message| will be copied if necessary.
+    ///
+    extern(System) void function (
+        cef_media_route_t* self,
+        const(void)* message,
+        size_t message_size) nothrow send_route_message;
+
+    ///
+    // Terminate this route. Will result in an asynchronous call to
+    // cef_media_observer_t::OnRoutes on all registered observers.
+    ///
+    extern(System) void function (cef_media_route_t* self) nothrow terminate;
+}
+
+
+
+///
+// Callback structure for cef_media_router_t::CreateRoute. The functions of this
+// structure will be called on the browser process UI thread.
+///
+struct cef_media_route_create_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be executed when the route creation has finished. |result|
+    // will be CEF_MRCR_OK if the route creation succeeded. |error| will be a
+    // description of the error if the route creation failed. |route| is the
+    // resulting route, or NULL if the route creation failed.
+    ///
+    extern(System) void function (
+        cef_media_route_create_callback_t* self,
+        cef_media_route_create_result_t result,
+        const(cef_string_t)* error,
+        cef_media_route_t* route) nothrow on_media_route_create_finished;
+}
+
+
+
+///
+// Represents a sink to which media can be routed. Instances of this object are
+// retrieved via cef_media_observer_t::OnSinks. The functions of this structure
+// may be called on any browser process thread unless otherwise indicated.
+///
+struct cef_media_sink_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the ID for this sink.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_media_sink_t* self) nothrow get_id;
+
+    ///
+    // Returns the name of this sink.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_media_sink_t* self) nothrow get_name;
+
+    ///
+    // Returns the description of this sink.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_media_sink_t* self) nothrow get_description;
+
+    ///
+    // Returns the icon type for this sink.
+    ///
+    extern(System) cef_media_sink_icon_type_t function (
+        cef_media_sink_t* self) nothrow get_icon_type;
+
+    ///
+    // Asynchronously retrieves device info.
+    ///
+    extern(System) void function (
+        cef_media_sink_t* self,
+        cef_media_sink_device_info_callback_t* callback) nothrow get_device_info;
+
+    ///
+    // Returns true (1) if this sink accepts content via Cast.
+    ///
+    extern(System) int function (cef_media_sink_t* self) nothrow is_cast_sink;
+
+    ///
+    // Returns true (1) if this sink accepts content via DIAL.
+    ///
+    extern(System) int function (cef_media_sink_t* self) nothrow is_dial_sink;
+
+    ///
+    // Returns true (1) if this sink is compatible with |source|.
+    ///
+    extern(System) int function (
+        cef_media_sink_t* self,
+        cef_media_source_t* source) nothrow is_compatible_with;
+}
+
+
+
+///
+// Callback structure for cef_media_sink_t::GetDeviceInfo. The functions of this
+// structure will be called on the browser process UI thread.
+///
+struct cef_media_sink_device_info_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be executed asyncronously once device information has been
+    // retrieved.
+    ///
+    extern(System) void function (
+        cef_media_sink_device_info_callback_t* self,
+        const(cef_media_sink_device_info_t)* device_info) nothrow on_media_sink_device_info;
+}
+
+
+
+///
+// Represents a source from which media can be routed. Instances of this object
+// are retrieved via cef_media_router_t::GetSource. The functions of this
+// structure may be called on any browser process thread unless otherwise
+// indicated.
+///
+struct cef_media_source_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the ID (media source URN or URL) for this source.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_media_source_t* self) nothrow get_id;
+
+    ///
+    // Returns true (1) if this source outputs its content via Cast.
+    ///
+    extern(System) int function (cef_media_source_t* self) nothrow is_cast_source;
+
+    ///
+    // Returns true (1) if this source outputs its content via DIAL.
+    ///
+    extern(System) int function (cef_media_source_t* self) nothrow is_dial_source;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_MEDIA_ROUTER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=28fa978051bd3ddff69d58e0dc8f445f64a61480$
+//
+
+extern (C):
+
+///
+// Supports creation and modification of menus. See cef_menu_id_t for the
+// command ids that have default implementations. All user-defined command ids
+// should be between MENU_ID_USER_FIRST and MENU_ID_USER_LAST. The functions of
+// this structure can only be accessed on the browser process the UI thread.
+///
+struct cef_menu_model_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this menu is a submenu.
+    ///
+    extern(System) int function (cef_menu_model_t* self) nothrow is_sub_menu;
+
+    ///
+    // Clears the menu. Returns true (1) on success.
+    ///
+    extern(System) int function (cef_menu_model_t* self) nothrow clear;
+
+    ///
+    // Returns the number of items in this menu.
+    ///
+    extern(System) int function (cef_menu_model_t* self) nothrow get_count;
+
+    ///
+    // Add a separator to the menu. Returns true (1) on success.
+    ///
+    extern(System) int function (cef_menu_model_t* self) nothrow add_separator;
+
+    ///
+    // Add an item to the menu. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        const(cef_string_t)* label) nothrow add_item;
+
+    ///
+    // Add a check item to the menu. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        const(cef_string_t)* label) nothrow add_check_item;
+
+    ///
+    // Add a radio item to the menu. Only a single item with the specified
+    // |group_id| can be checked at a time. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        const(cef_string_t)* label,
+        int group_id) nothrow add_radio_item;
+
+    ///
+    // Add a sub-menu to the menu. The new sub-menu is returned.
+    ///
+    extern(System) cef_menu_model_t* function (
+        cef_menu_model_t* self,
+        int command_id,
+        const(cef_string_t)* label) nothrow add_sub_menu;
+
+    ///
+    // Insert a separator in the menu at the specified |index|. Returns true (1)
+    // on success.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int index) nothrow insert_separator_at;
+
+    ///
+    // Insert an item in the menu at the specified |index|. Returns true (1) on
+    // success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int command_id,
+        const(cef_string_t)* label) nothrow insert_item_at;
+
+    ///
+    // Insert a check item in the menu at the specified |index|. Returns true (1)
+    // on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int command_id,
+        const(cef_string_t)* label) nothrow insert_check_item_at;
+
+    ///
+    // Insert a radio item in the menu at the specified |index|. Only a single
+    // item with the specified |group_id| can be checked at a time. Returns true
+    // (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int command_id,
+        const(cef_string_t)* label,
+        int group_id) nothrow insert_radio_item_at;
+
+    ///
+    // Insert a sub-menu in the menu at the specified |index|. The new sub-menu is
+    // returned.
+    ///
+    extern(System) cef_menu_model_t* function (
+        cef_menu_model_t* self,
+        int index,
+        int command_id,
+        const(cef_string_t)* label) nothrow insert_sub_menu_at;
+
+    ///
+    // Removes the item with the specified |command_id|. Returns true (1) on
+    // success.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int command_id) nothrow remove;
+
+    ///
+    // Removes the item at the specified |index|. Returns true (1) on success.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int index) nothrow remove_at;
+
+    ///
+    // Returns the index associated with the specified |command_id| or -1 if not
+    // found due to the command id not existing in the menu.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int command_id) nothrow get_index_of;
+
+    ///
+    // Returns the command id at the specified |index| or -1 if not found due to
+    // invalid range or the index being a separator.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int index) nothrow get_command_id_at;
+
+    ///
+    // Sets the command id at the specified |index|. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int command_id) nothrow set_command_id_at;
+
+    ///
+    // Returns the label for the specified |command_id| or NULL if not found.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_menu_model_t* self,
+        int command_id) nothrow get_label;
+
+    ///
+    // Returns the label at the specified |index| or NULL if not found due to
+    // invalid range or the index being a separator.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_menu_model_t* self,
+        int index) nothrow get_label_at;
+
+    ///
+    // Sets the label for the specified |command_id|. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        const(cef_string_t)* label) nothrow set_label;
+
+    ///
+    // Set the label at the specified |index|. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        const(cef_string_t)* label) nothrow set_label_at;
+
+    ///
+    // Returns the item type for the specified |command_id|.
+    ///
+    extern(System) cef_menu_item_type_t function (
+        cef_menu_model_t* self,
+        int command_id) nothrow get_type;
+
+    ///
+    // Returns the item type at the specified |index|.
+    ///
+    extern(System) cef_menu_item_type_t function (
+        cef_menu_model_t* self,
+        int index) nothrow get_type_at;
+
+    ///
+    // Returns the group id for the specified |command_id| or -1 if invalid.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int command_id) nothrow get_group_id;
+
+    ///
+    // Returns the group id at the specified |index| or -1 if invalid.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int index) nothrow get_group_id_at;
+
+    ///
+    // Sets the group id for the specified |command_id|. Returns true (1) on
+    // success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        int group_id) nothrow set_group_id;
+
+    ///
+    // Sets the group id at the specified |index|. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int group_id) nothrow set_group_id_at;
+
+    ///
+    // Returns the submenu for the specified |command_id| or NULL if invalid.
+    ///
+    extern(System) cef_menu_model_t* function (
+        cef_menu_model_t* self,
+        int command_id) nothrow get_sub_menu;
+
+    ///
+    // Returns the submenu at the specified |index| or NULL if invalid.
+    ///
+    extern(System) cef_menu_model_t* function (
+        cef_menu_model_t* self,
+        int index) nothrow get_sub_menu_at;
+
+    ///
+    // Returns true (1) if the specified |command_id| is visible.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int command_id) nothrow is_visible;
+
+    ///
+    // Returns true (1) if the specified |index| is visible.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int index) nothrow is_visible_at;
+
+    ///
+    // Change the visibility of the specified |command_id|. Returns true (1) on
+    // success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        int visible) nothrow set_visible;
+
+    ///
+    // Change the visibility at the specified |index|. Returns true (1) on
+    // success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int visible) nothrow set_visible_at;
+
+    ///
+    // Returns true (1) if the specified |command_id| is enabled.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int command_id) nothrow is_enabled;
+
+    ///
+    // Returns true (1) if the specified |index| is enabled.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int index) nothrow is_enabled_at;
+
+    ///
+    // Change the enabled status of the specified |command_id|. Returns true (1)
+    // on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        int enabled) nothrow set_enabled;
+
+    ///
+    // Change the enabled status at the specified |index|. Returns true (1) on
+    // success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int enabled) nothrow set_enabled_at;
+
+    ///
+    // Returns true (1) if the specified |command_id| is checked. Only applies to
+    // check and radio items.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int command_id) nothrow is_checked;
+
+    ///
+    // Returns true (1) if the specified |index| is checked. Only applies to check
+    // and radio items.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int index) nothrow is_checked_at;
+
+    ///
+    // Check the specified |command_id|. Only applies to check and radio items.
+    // Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        int checked) nothrow set_checked;
+
+    ///
+    // Check the specified |index|. Only applies to check and radio items. Returns
+    // true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int checked) nothrow set_checked_at;
+
+    ///
+    // Returns true (1) if the specified |command_id| has a keyboard accelerator
+    // assigned.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int command_id) nothrow has_accelerator;
+
+    ///
+    // Returns true (1) if the specified |index| has a keyboard accelerator
+    // assigned.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int index) nothrow has_accelerator_at;
+
+    ///
+    // Set the keyboard accelerator for the specified |command_id|. |key_code| can
+    // be any virtual key or character value. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        int key_code,
+        int shift_pressed,
+        int ctrl_pressed,
+        int alt_pressed) nothrow set_accelerator;
+
+    ///
+    // Set the keyboard accelerator at the specified |index|. |key_code| can be
+    // any virtual key or character value. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int key_code,
+        int shift_pressed,
+        int ctrl_pressed,
+        int alt_pressed) nothrow set_accelerator_at;
+
+    ///
+    // Remove the keyboard accelerator for the specified |command_id|. Returns
+    // true (1) on success.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int command_id) nothrow remove_accelerator;
+
+    ///
+    // Remove the keyboard accelerator at the specified |index|. Returns true (1)
+    // on success.
+    ///
+    extern(System) int function (cef_menu_model_t* self, int index) nothrow remove_accelerator_at;
+
+    ///
+    // Retrieves the keyboard accelerator for the specified |command_id|. Returns
+    // true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        int* key_code,
+        int* shift_pressed,
+        int* ctrl_pressed,
+        int* alt_pressed) nothrow get_accelerator;
+
+    ///
+    // Retrieves the keyboard accelerator for the specified |index|. Returns true
+    // (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        int* key_code,
+        int* shift_pressed,
+        int* ctrl_pressed,
+        int* alt_pressed) nothrow get_accelerator_at;
+
+    ///
+    // Set the explicit color for |command_id| and |color_type| to |color|.
+    // Specify a |color| value of 0 to remove the explicit color. If no explicit
+    // color or default color is set for |color_type| then the system color will
+    // be used. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        cef_menu_color_type_t color_type,
+        cef_color_t color) nothrow set_color;
+
+    ///
+    // Set the explicit color for |command_id| and |index| to |color|. Specify a
+    // |color| value of 0 to remove the explicit color. Specify an |index| value
+    // of -1 to set the default color for items that do not have an explicit color
+    // set. If no explicit color or default color is set for |color_type| then the
+    // system color will be used. Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        cef_menu_color_type_t color_type,
+        cef_color_t color) nothrow set_color_at;
+
+    ///
+    // Returns in |color| the color that was explicitly set for |command_id| and
+    // |color_type|. If a color was not set then 0 will be returned in |color|.
+    // Returns true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        cef_menu_color_type_t color_type,
+        cef_color_t* color) nothrow get_color;
+
+    ///
+    // Returns in |color| the color that was explicitly set for |command_id| and
+    // |color_type|. Specify an |index| value of -1 to return the default color in
+    // |color|. If a color was not set then 0 will be returned in |color|. Returns
+    // true (1) on success.
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        cef_menu_color_type_t color_type,
+        cef_color_t* color) nothrow get_color_at;
+
+    ///
+    // Sets the font list for the specified |command_id|. If |font_list| is NULL
+    // the system font will be used. Returns true (1) on success. The format is
+    // "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where: - FONT_FAMILY_LIST is a comma-
+    // separated list of font family names, - STYLES is an optional space-
+    // separated list of style names (case-sensitive
+    //   "Bold" and "Italic" are supported), and
+    // - SIZE is an integer font size in pixels with the suffix "px".
+    //
+    // Here are examples of valid font description strings: - "Arial, Helvetica,
+    // Bold Italic 14px" - "Arial, 14px"
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int command_id,
+        const(cef_string_t)* font_list) nothrow set_font_list;
+
+    ///
+    // Sets the font list for the specified |index|. Specify an |index| value of
+    // -1 to set the default font. If |font_list| is NULL the system font will be
+    // used. Returns true (1) on success. The format is
+    // "<FONT_FAMILY_LIST>,[STYLES] <SIZE>", where: - FONT_FAMILY_LIST is a comma-
+    // separated list of font family names, - STYLES is an optional space-
+    // separated list of style names (case-sensitive
+    //   "Bold" and "Italic" are supported), and
+    // - SIZE is an integer font size in pixels with the suffix "px".
+    //
+    // Here are examples of valid font description strings: - "Arial, Helvetica,
+    // Bold Italic 14px" - "Arial, 14px"
+    ///
+    extern(System) int function (
+        cef_menu_model_t* self,
+        int index,
+        const(cef_string_t)* font_list) nothrow set_font_list_at;
+}
+
+
+
+///
+// Create a new MenuModel with the specified |delegate|.
+///
+cef_menu_model_t* cef_menu_model_create (cef_menu_model_delegate_t* delegate_);
+
+// CEF_INCLUDE_CAPI_CEF_MENU_MODEL_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=edc411cb0447a6c2965cdeb5f709fe56c43ec2bb$
+//
+
+extern (C):
+
+
+
+///
+// Implement this structure to handle menu model events. The functions of this
+// structure will be called on the browser process UI thread unless otherwise
+// indicated.
+///
+struct cef_menu_model_delegate_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Perform the action associated with the specified |command_id| and optional
+    // |event_flags|.
+    ///
+    extern(System) void function (
+        cef_menu_model_delegate_t* self,
+        cef_menu_model_t* menu_model,
+        int command_id,
+        cef_event_flags_t event_flags) nothrow execute_command;
+
+    ///
+    // Called when the user moves the mouse outside the menu and over the owning
+    // window.
+    ///
+    extern(System) void function (
+        cef_menu_model_delegate_t* self,
+        cef_menu_model_t* menu_model,
+        const(cef_point_t)* screen_point) nothrow mouse_outside_menu;
+
+    ///
+    // Called on unhandled open submenu keyboard commands. |is_rtl| will be true
+    // (1) if the menu is displaying a right-to-left language.
+    ///
+    extern(System) void function (
+        cef_menu_model_delegate_t* self,
+        cef_menu_model_t* menu_model,
+        int is_rtl) nothrow unhandled_open_submenu;
+
+    ///
+    // Called on unhandled close submenu keyboard commands. |is_rtl| will be true
+    // (1) if the menu is displaying a right-to-left language.
+    ///
+    extern(System) void function (
+        cef_menu_model_delegate_t* self,
+        cef_menu_model_t* menu_model,
+        int is_rtl) nothrow unhandled_close_submenu;
+
+    ///
+    // The menu is about to show.
+    ///
+    extern(System) void function (
+        cef_menu_model_delegate_t* self,
+        cef_menu_model_t* menu_model) nothrow menu_will_show;
+
+    ///
+    // The menu has closed.
+    ///
+    extern(System) void function (
+        cef_menu_model_delegate_t* self,
+        cef_menu_model_t* menu_model) nothrow menu_closed;
+
+    ///
+    // Optionally modify a menu item label. Return true (1) if |label| was
+    // modified.
+    ///
+    extern(System) int function (
+        cef_menu_model_delegate_t* self,
+        cef_menu_model_t* menu_model,
+        cef_string_t* label) nothrow format_label;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_MENU_MODEL_DELEGATE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=f14afbd6941bcb37b14cce81569882512c3d7194$
+//
+
+extern (C):
+
+///
+// Structure used to represent an entry in navigation history.
+///
+struct cef_navigation_entry_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is valid. Do not call any other functions
+    // if this function returns false (0).
+    ///
+    extern(System) int function (cef_navigation_entry_t* self) nothrow is_valid;
+
+    ///
+    // Returns the actual URL of the page. For some pages this may be data: URL or
+    // similar. Use get_display_url() to return a display-friendly version.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_navigation_entry_t* self) nothrow get_url;
+
+    ///
+    // Returns a display-friendly version of the URL.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_navigation_entry_t* self) nothrow get_display_url;
+
+    ///
+    // Returns the original URL that was entered by the user before any redirects.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_navigation_entry_t* self) nothrow get_original_url;
+
+    ///
+    // Returns the title set by the page. This value may be NULL.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_navigation_entry_t* self) nothrow get_title;
+
+    ///
+    // Returns the transition type which indicates what the user did to move to
+    // this page from the previous page.
+    ///
+    extern(System) cef_transition_type_t function (
+        cef_navigation_entry_t* self) nothrow get_transition_type;
+
+    ///
+    // Returns true (1) if this navigation includes post data.
+    ///
+    extern(System) int function (cef_navigation_entry_t* self) nothrow has_post_data;
+
+    ///
+    // Returns the time for the last known successful navigation completion. A
+    // navigation may be completed more than once if the page is reloaded. May be
+    // 0 if the navigation has not yet completed.
+    ///
+    extern(System) cef_time_t function (cef_navigation_entry_t* self) nothrow get_completion_time;
+
+    ///
+    // Returns the HTTP status code for the last known successful navigation
+    // response. May be 0 if the response has not yet been received or if the
+    // navigation has not yet completed.
+    ///
+    extern(System) int function (cef_navigation_entry_t* self) nothrow get_http_status_code;
+
+    ///
+    // Returns the SSL information for this navigation entry.
+    ///
+    extern(System) cef_sslstatus_t* function (cef_navigation_entry_t* self) nothrow get_sslstatus;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_NAVIGATION_ENTRY_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=6798e6147540596c1abac8c7457d9d1d4d99bd54$
+//
+
+extern (C):
+
+///
+// Add an entry to the cross-origin access whitelist.
+//
+// The same-origin policy restricts how scripts hosted from different origins
+// (scheme + domain + port) can communicate. By default, scripts can only access
+// resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes
+// (but no other schemes) can use the "Access-Control-Allow-Origin" header to
+// allow cross-origin requests. For example, https://source.example.com can make
+// XMLHttpRequest requests on http://target.example.com if the
+// http://target.example.com request returns an "Access-Control-Allow-Origin:
+// https://source.example.com" response header.
+//
+// Scripts in separate frames or iframes and hosted from the same protocol and
+// domain suffix can execute cross-origin JavaScript if both pages set the
+// document.domain value to the same domain suffix. For example,
+// scheme://foo.example.com and scheme://bar.example.com can communicate using
+// JavaScript if both domains set document.domain="example.com".
+//
+// This function is used to allow access to origins that would otherwise violate
+// the same-origin policy. Scripts hosted underneath the fully qualified
+// |source_origin| URL (like http://www.example.com) will be allowed access to
+// all resources hosted on the specified |target_protocol| and |target_domain|.
+// If |target_domain| is non-NULL and |allow_target_subdomains| if false (0)
+// only exact domain matches will be allowed. If |target_domain| contains a top-
+// level domain component (like "example.com") and |allow_target_subdomains| is
+// true (1) sub-domain matches will be allowed. If |target_domain| is NULL and
+// |allow_target_subdomains| if true (1) all domains and IP addresses will be
+// allowed.
+//
+// This function cannot be used to bypass the restrictions on local or display
+// isolated schemes. See the comments on CefRegisterCustomScheme for more
+// information.
+//
+// This function may be called on any thread. Returns false (0) if
+// |source_origin| is invalid or the whitelist cannot be accessed.
+///
+int cef_add_cross_origin_whitelist_entry (
+    const(cef_string_t)* source_origin,
+    const(cef_string_t)* target_protocol,
+    const(cef_string_t)* target_domain,
+    int allow_target_subdomains);
+
+///
+// Remove an entry from the cross-origin access whitelist. Returns false (0) if
+// |source_origin| is invalid or the whitelist cannot be accessed.
+///
+int cef_remove_cross_origin_whitelist_entry (
+    const(cef_string_t)* source_origin,
+    const(cef_string_t)* target_protocol,
+    const(cef_string_t)* target_domain,
+    int allow_target_subdomains);
+
+///
+// Remove all entries from the cross-origin access whitelist. Returns false (0)
+// if the whitelist cannot be accessed.
+///
+int cef_clear_cross_origin_whitelist ();
+
+// CEF_INCLUDE_CAPI_CEF_ORIGIN_WHITELIST_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=84149324b177c47287b935dcb3d5900a33acfdf5$
+//
+
+extern (C):
+
+///
+// Parse the specified |url| into its component parts. Returns false (0) if the
+// URL is NULL or invalid.
+///
+int cef_parse_url (const(cef_string_t)* url, cef_urlparts_t* parts);
+
+///
+// Creates a URL from the specified |parts|, which must contain a non-NULL spec
+// or a non-NULL host and path (at a minimum), but not both. Returns false (0)
+// if |parts| isn't initialized as described.
+///
+int cef_create_url (const(cef_urlparts_t)* parts, cef_string_t* url);
+
+///
+// This is a convenience function for formatting a URL in a concise and human-
+// friendly way to help users make security-related decisions (or in other
+// circumstances when people need to distinguish sites, origins, or otherwise-
+// simplified URLs from each other). Internationalized domain names (IDN) may be
+// presented in Unicode if the conversion is considered safe. The returned value
+// will (a) omit the path for standard schemes, excepting file and filesystem,
+// and (b) omit the port if it is the default for the scheme. Do not use this
+// for URLs which will be parsed or sent to other applications.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+cef_string_userfree_t cef_format_url_for_security_display (
+    const(cef_string_t)* origin_url);
+
+///
+// Returns the mime type for the specified file extension or an NULL string if
+// unknown.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+cef_string_userfree_t cef_get_mime_type (const(cef_string_t)* extension);
+
+///
+// Get the extensions associated with the given mime type. This should be passed
+// in lower case. There could be multiple extensions for a given mime type, like
+// "html,htm" for "text/html", or "txt,text,html,..." for "text/*". Any existing
+// elements in the provided vector will not be erased.
+///
+void cef_get_extensions_for_mime_type (
+    const(cef_string_t)* mime_type,
+    cef_string_list_t extensions);
+
+///
+// Encodes |data| as a base64 string.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+cef_string_userfree_t cef_base64encode (const(void)* data, size_t data_size);
+
+///
+// Decodes the base64 encoded string |data|. The returned value will be NULL if
+// the decoding fails.
+///
+
+cef_binary_value_t* cef_base64decode (const(cef_string_t)* data);
+
+///
+// Escapes characters in |text| which are unsuitable for use as a query
+// parameter value. Everything except alphanumerics and -_.!~*'() will be
+// converted to "%XX". If |use_plus| is true (1) spaces will change to "+". The
+// result is basically the same as encodeURIComponent in Javacript.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+cef_string_userfree_t cef_uriencode (const(cef_string_t)* text, int use_plus);
+
+///
+// Unescapes |text| and returns the result. Unescaping consists of looking for
+// the exact pattern "%XX" where each X is a hex digit and converting to the
+// character with the numerical value of those digits (e.g. "i%20=%203%3b"
+// unescapes to "i = 3;"). If |convert_to_utf8| is true (1) this function will
+// attempt to interpret the initial decoded result as UTF-8. If the result is
+// convertable into UTF-8 it will be returned as converted. Otherwise the
+// initial decoded result will be returned.  The |unescape_rule| parameter
+// supports further customization the decoding process.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+cef_string_userfree_t cef_uridecode (
+    const(cef_string_t)* text,
+    int convert_to_utf8,
+    cef_uri_unescape_rule_t unescape_rule);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this function returns NULL.
+///
+
+cef_value_t* cef_parse_json (
+    const(cef_string_t)* json_string,
+    cef_json_parser_options_t options);
+
+///
+// Parses the specified UTF8-encoded |json| buffer of size |json_size| and
+// returns a dictionary or list representation. If JSON parsing fails this
+// function returns NULL.
+///
+cef_value_t* cef_parse_json_buffer (
+    const(void)* json,
+    size_t json_size,
+    cef_json_parser_options_t options);
+
+///
+// Parses the specified |json_string| and returns a dictionary or list
+// representation. If JSON parsing fails this function returns NULL and
+// populates |error_msg_out| with a formatted error message.
+///
+cef_value_t* cef_parse_jsonand_return_error (
+    const(cef_string_t)* json_string,
+    cef_json_parser_options_t options,
+    cef_string_t* error_msg_out);
+
+///
+// Generates a JSON string from the specified root |node| which should be a
+// dictionary or list value. Returns an NULL string on failure. This function
+// requires exclusive access to |node| including any underlying data.
+///
+// The resulting string must be freed by calling cef_string_userfree_free().
+cef_string_userfree_t cef_write_json (
+    cef_value_t* node,
+    cef_json_writer_options_t options);
+
+// CEF_INCLUDE_CAPI_CEF_PARSER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=0ae1fe7f7141eb05eb7fd44c2d41e4c576afae1e$
+//
+
+extern (C):
+
+///
+// Retrieve the path associated with the specified |key|. Returns true (1) on
+// success. Can be called on any thread in the browser process.
+///
+int cef_get_path (cef_path_key_t key, cef_string_t* path);
+
+// CEF_INCLUDE_CAPI_CEF_PATH_UTIL_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=84fc58b3898f25476d9cdd260553390ba5e0b30b$
+//
+
+extern (C):
+
+///
+// Callback structure for asynchronous continuation of print dialog requests.
+///
+struct cef_print_dialog_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Continue printing with the specified |settings|.
+    ///
+    extern(System) void function (
+        cef_print_dialog_callback_t* self,
+        cef_print_settings_t* settings) nothrow cont;
+
+    ///
+    // Cancel the printing.
+    ///
+    extern(System) void function (cef_print_dialog_callback_t* self) nothrow cancel;
+}
+
+
+
+///
+// Callback structure for asynchronous continuation of print job requests.
+///
+struct cef_print_job_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Indicate completion of the print job.
+    ///
+    extern(System) void function (cef_print_job_callback_t* self) nothrow cont;
+}
+
+
+
+///
+// Implement this structure to handle printing on Linux. Each browser will have
+// only one print job in progress at a time. The functions of this structure
+// will be called on the browser process UI thread.
+///
+struct cef_print_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called when printing has started for the specified |browser|. This function
+    // will be called before the other OnPrint*() functions and irrespective of
+    // how printing was initiated (e.g. cef_browser_host_t::print(), JavaScript
+    // window.print() or PDF extension print button).
+    ///
+    extern(System) void function (
+        cef_print_handler_t* self,
+        cef_browser_t* browser) nothrow on_print_start;
+
+    ///
+    // Synchronize |settings| with client state. If |get_defaults| is true (1)
+    // then populate |settings| with the default print settings. Do not keep a
+    // reference to |settings| outside of this callback.
+    ///
+    extern(System) void function (
+        cef_print_handler_t* self,
+        cef_browser_t* browser,
+        cef_print_settings_t* settings,
+        int get_defaults) nothrow on_print_settings;
+
+    ///
+    // Show the print dialog. Execute |callback| once the dialog is dismissed.
+    // Return true (1) if the dialog will be displayed or false (0) to cancel the
+    // printing immediately.
+    ///
+    extern(System) int function (
+        cef_print_handler_t* self,
+        cef_browser_t* browser,
+        int has_selection,
+        cef_print_dialog_callback_t* callback) nothrow on_print_dialog;
+
+    ///
+    // Send the print job to the printer. Execute |callback| once the job is
+    // completed. Return true (1) if the job will proceed or false (0) to cancel
+    // the job immediately.
+    ///
+    extern(System) int function (
+        cef_print_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* document_name,
+        const(cef_string_t)* pdf_file_path,
+        cef_print_job_callback_t* callback) nothrow on_print_job;
+
+    ///
+    // Reset client state related to printing.
+    ///
+    extern(System) void function (
+        cef_print_handler_t* self,
+        cef_browser_t* browser) nothrow on_print_reset;
+
+    ///
+    // Return the PDF paper size in device units. Used in combination with
+    // cef_browser_host_t::print_to_pdf().
+    ///
+    extern(System) cef_size_t function (
+        cef_print_handler_t* self,
+        cef_browser_t* browser,
+        int device_units_per_inch) nothrow get_pdf_paper_size;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_PRINT_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=4b52323c4ce2d0ebcc3438e16fc9a9b181a58adc$
+//
+
+extern (C):
+
+///
+// Structure representing print settings.
+///
+struct cef_print_settings_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is valid. Do not call any other functions
+    // if this function returns false (0).
+    ///
+    extern(System) int function (cef_print_settings_t* self) nothrow is_valid;
+
+    ///
+    // Returns true (1) if the values of this object are read-only. Some APIs may
+    // expose read-only objects.
+    ///
+    extern(System) int function (cef_print_settings_t* self) nothrow is_read_only;
+
+    ///
+    // Set the page orientation.
+    ///
+    extern(System) void function (cef_print_settings_t* self, int landscape) nothrow set_orientation;
+
+    ///
+    // Returns true (1) if the orientation is landscape.
+    ///
+    extern(System) int function (cef_print_settings_t* self) nothrow is_landscape;
+
+    ///
+    // Set the printer printable area in device units. Some platforms already
+    // provide flipped area. Set |landscape_needs_flip| to false (0) on those
+    // platforms to avoid double flipping.
+    ///
+    extern(System) void function (
+        cef_print_settings_t* self,
+        const(cef_size_t)* physical_size_device_units,
+        const(cef_rect_t)* printable_area_device_units,
+        int landscape_needs_flip) nothrow set_printer_printable_area;
+
+    ///
+    // Set the device name.
+    ///
+    extern(System) void function (
+        cef_print_settings_t* self,
+        const(cef_string_t)* name) nothrow set_device_name;
+
+    ///
+    // Get the device name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_print_settings_t* self) nothrow get_device_name;
+
+    ///
+    // Set the DPI (dots per inch).
+    ///
+    extern(System) void function (cef_print_settings_t* self, int dpi) nothrow set_dpi;
+
+    ///
+    // Get the DPI (dots per inch).
+    ///
+    extern(System) int function (cef_print_settings_t* self) nothrow get_dpi;
+
+    ///
+    // Set the page ranges.
+    ///
+    extern(System) void function (
+        cef_print_settings_t* self,
+        size_t rangesCount,
+        const(cef_range_t)* ranges) nothrow set_page_ranges;
+
+    ///
+    // Returns the number of page ranges that currently exist.
+    ///
+    extern(System) size_t function (cef_print_settings_t* self) nothrow get_page_ranges_count;
+
+    ///
+    // Retrieve the page ranges.
+    ///
+    extern(System) void function (
+        cef_print_settings_t* self,
+        size_t* rangesCount,
+        cef_range_t* ranges) nothrow get_page_ranges;
+
+    ///
+    // Set whether only the selection will be printed.
+    ///
+    extern(System) void function (
+        cef_print_settings_t* self,
+        int selection_only) nothrow set_selection_only;
+
+    ///
+    // Returns true (1) if only the selection will be printed.
+    ///
+    extern(System) int function (cef_print_settings_t* self) nothrow is_selection_only;
+
+    ///
+    // Set whether pages will be collated.
+    ///
+    extern(System) void function (cef_print_settings_t* self, int collate) nothrow set_collate;
+
+    ///
+    // Returns true (1) if pages will be collated.
+    ///
+    extern(System) int function (cef_print_settings_t* self) nothrow will_collate;
+
+    ///
+    // Set the color model.
+    ///
+    extern(System) void function (
+        cef_print_settings_t* self,
+        cef_color_model_t model) nothrow set_color_model;
+
+    ///
+    // Get the color model.
+    ///
+    extern(System) cef_color_model_t function (cef_print_settings_t* self) nothrow get_color_model;
+
+    ///
+    // Set the number of copies.
+    ///
+    extern(System) void function (cef_print_settings_t* self, int copies) nothrow set_copies;
+
+    ///
+    // Get the number of copies.
+    ///
+    extern(System) int function (cef_print_settings_t* self) nothrow get_copies;
+
+    ///
+    // Set the duplex mode.
+    ///
+    extern(System) void function (
+        cef_print_settings_t* self,
+        cef_duplex_mode_t mode) nothrow set_duplex_mode;
+
+    ///
+    // Get the duplex mode.
+    ///
+    extern(System) cef_duplex_mode_t function (cef_print_settings_t* self) nothrow get_duplex_mode;
+}
+
+
+
+///
+// Create a new cef_print_settings_t object.
+///
+cef_print_settings_t* cef_print_settings_create ();
+
+// CEF_INCLUDE_CAPI_CEF_PRINT_SETTINGS_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=53ff22b73527aa331d2bd96e008f4cb4f0413042$
+//
+
+extern (C):
+
+///
+// Structure representing a message. Can be used on any process and thread.
+///
+struct cef_process_message_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is valid. Do not call any other functions
+    // if this function returns false (0).
+    ///
+    extern(System) int function (cef_process_message_t* self) nothrow is_valid;
+
+    ///
+    // Returns true (1) if the values of this object are read-only. Some APIs may
+    // expose read-only objects.
+    ///
+    extern(System) int function (cef_process_message_t* self) nothrow is_read_only;
+
+    ///
+    // Returns a writable copy of this object.
+    ///
+    extern(System) cef_process_message_t* function (cef_process_message_t* self) nothrow copy;
+
+    ///
+    // Returns the message name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_process_message_t* self) nothrow get_name;
+
+    ///
+    // Returns the list of arguments.
+    ///
+    extern(System) cef_list_value_t* function (
+        cef_process_message_t* self) nothrow get_argument_list;
+}
+
+
+
+///
+// Create a new cef_process_message_t object with the specified name.
+///
+cef_process_message_t* cef_process_message_create (const(cef_string_t)* name);
+
+// CEF_INCLUDE_CAPI_CEF_PROCESS_MESSAGE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=c476a8d22852994d9d9695db901efaef13bbfc9d$
+//
+
+extern (C):
+
+///
+// Launches the process specified via |command_line|. Returns true (1) upon
+// success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.
+//
+// Unix-specific notes: - All file descriptors open in the parent process will
+// be closed in the
+//   child process except for stdin, stdout, and stderr.
+// - If the first argument on the command line does not contain a slash,
+//   PATH will be searched. (See man execvp.)
+///
+int cef_launch_process (cef_command_line_t* command_line);
+
+// CEF_INCLUDE_CAPI_CEF_PROCESS_UTIL_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=8cde223bdb8d25ff163edd95da0d9e238b298016$
+//
+
+extern (C):
+
+///
+// Generic callback structure used for managing the lifespan of a registration.
+///
+struct cef_registration_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_REGISTRATION_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=e4bdab963041a270edabc0954b415eb4cae8e5cb$
+//
+
+extern (C):
+
+///
+// Implement this structure to handle events when window rendering is disabled.
+// The functions of this structure will be called on the UI thread.
+///
+struct cef_render_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Return the handler for accessibility notifications. If no handler is
+    // provided the default implementation will be used.
+    ///
+    extern(System) cef_accessibility_handler_t* function (
+        cef_render_handler_t* self) nothrow get_accessibility_handler;
+
+    ///
+    // Called to retrieve the root window rectangle in screen coordinates. Return
+    // true (1) if the rectangle was provided. If this function returns false (0)
+    // the rectangle from GetViewRect will be used.
+    ///
+    extern(System) int function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        cef_rect_t* rect) nothrow get_root_screen_rect;
+
+    ///
+    // Called to retrieve the view rectangle which is relative to screen
+    // coordinates. This function must always provide a non-NULL rectangle.
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        cef_rect_t* rect) nothrow get_view_rect;
+
+    ///
+    // Called to retrieve the translation from view coordinates to actual screen
+    // coordinates. Return true (1) if the screen coordinates were provided.
+    ///
+    extern(System) int function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        int viewX,
+        int viewY,
+        int* screenX,
+        int* screenY) nothrow get_screen_point;
+
+    ///
+    // Called to allow the client to fill in the CefScreenInfo object with
+    // appropriate values. Return true (1) if the |screen_info| structure has been
+    // modified.
+    //
+    // If the screen info rectangle is left NULL the rectangle from GetViewRect
+    // will be used. If the rectangle is still NULL or invalid popups may not be
+    // drawn correctly.
+    ///
+    extern(System) int function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        cef_screen_info_t* screen_info) nothrow get_screen_info;
+
+    ///
+    // Called when the browser wants to show or hide the popup widget. The popup
+    // should be shown if |show| is true (1) and hidden if |show| is false (0).
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        int show) nothrow on_popup_show;
+
+    ///
+    // Called when the browser wants to move or resize the popup widget. |rect|
+    // contains the new location and size in view coordinates.
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_rect_t)* rect) nothrow on_popup_size;
+
+    ///
+    // Called when an element should be painted. Pixel values passed to this
+    // function are scaled relative to view coordinates based on the value of
+    // CefScreenInfo.device_scale_factor returned from GetScreenInfo. |type|
+    // indicates whether the element is the view or the popup widget. |buffer|
+    // contains the pixel data for the whole image. |dirtyRects| contains the set
+    // of rectangles in pixel coordinates that need to be repainted. |buffer| will
+    // be |width|*|height|*4 bytes in size and represents a BGRA image with an
+    // upper-left origin. This function is only called when
+    // cef_window_tInfo::shared_texture_enabled is set to false (0).
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        cef_paint_element_type_t type,
+        size_t dirtyRectsCount,
+        const(cef_rect_t)* dirtyRects,
+        const(void)* buffer,
+        int width,
+        int height) nothrow on_paint;
+
+    ///
+    // Called when an element has been rendered to the shared texture handle.
+    // |type| indicates whether the element is the view or the popup widget.
+    // |dirtyRects| contains the set of rectangles in pixel coordinates that need
+    // to be repainted. |shared_handle| is the handle for a D3D11 Texture2D that
+    // can be accessed via ID3D11Device using the OpenSharedResource function.
+    // This function is only called when cef_window_tInfo::shared_texture_enabled
+    // is set to true (1), and is currently only supported on Windows.
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        cef_paint_element_type_t type,
+        size_t dirtyRectsCount,
+        const(cef_rect_t)* dirtyRects,
+        void* shared_handle) nothrow on_accelerated_paint;
+
+    ///
+    // Called when the user starts dragging content in the web view. Contextual
+    // information about the dragged content is supplied by |drag_data|. (|x|,
+    // |y|) is the drag start location in screen coordinates. OS APIs that run a
+    // system message loop may be used within the StartDragging call.
+    //
+    // Return false (0) to abort the drag operation. Don't call any of
+    // cef_browser_host_t::DragSource*Ended* functions after returning false (0).
+    //
+    // Return true (1) to handle the drag operation. Call
+    // cef_browser_host_t::DragSourceEndedAt and DragSourceSystemDragEnded either
+    // synchronously or asynchronously to inform the web view that the drag
+    // operation has ended.
+    ///
+    extern(System) int function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        cef_drag_data_t* drag_data,
+        cef_drag_operations_mask_t allowed_ops,
+        int x,
+        int y) nothrow start_dragging;
+
+    ///
+    // Called when the web view wants to update the mouse cursor during a drag &
+    // drop operation. |operation| describes the allowed operation (none, move,
+    // copy, link).
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        cef_drag_operations_mask_t operation) nothrow update_drag_cursor;
+
+    ///
+    // Called when the scroll offset has changed.
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        double x,
+        double y) nothrow on_scroll_offset_changed;
+
+    ///
+    // Called when the IME composition range has changed. |selected_range| is the
+    // range of characters that have been selected. |character_bounds| is the
+    // bounds of each character in view coordinates.
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_range_t)* selected_range,
+        size_t character_boundsCount,
+        const(cef_rect_t)* character_bounds) nothrow on_ime_composition_range_changed;
+
+    ///
+    // Called when text selection has changed for the specified |browser|.
+    // |selected_text| is the currently selected text and |selected_range| is the
+    // character range.
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* selected_text,
+        const(cef_range_t)* selected_range) nothrow on_text_selection_changed;
+
+    ///
+    // Called when an on-screen keyboard should be shown or hidden for the
+    // specified |browser|. |input_mode| specifies what kind of keyboard should be
+    // opened. If |input_mode| is CEF_TEXT_INPUT_MODE_NONE, any existing keyboard
+    // for this browser should be hidden.
+    ///
+    extern(System) void function (
+        cef_render_handler_t* self,
+        cef_browser_t* browser,
+        cef_text_input_mode_t input_mode) nothrow on_virtual_keyboard_requested;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=4ebf99611a11cc8714d710c37417fbd9f50f0618$
+//
+
+extern (C):
+
+///
+// Structure used to implement render process callbacks. The functions of this
+// structure will be called on the render process main thread (TID_RENDERER)
+// unless otherwise indicated.
+///
+struct cef_render_process_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called after WebKit has been initialized.
+    ///
+    extern(System) void function (cef_render_process_handler_t* self) nothrow on_web_kit_initialized;
+
+    ///
+    // Called after a browser has been created. When browsing cross-origin a new
+    // browser will be created before the old browser with the same identifier is
+    // destroyed. |extra_info| is an optional read-only value originating from
+    // cef_browser_host_t::cef_browser_host_create_browser(),
+    // cef_browser_host_t::cef_browser_host_create_browser_sync(),
+    // cef_life_span_handler_t::on_before_popup() or
+    // cef_browser_view_t::cef_browser_view_create().
+    ///
+    extern(System) void function (
+        cef_render_process_handler_t* self,
+        cef_browser_t* browser,
+        cef_dictionary_value_t* extra_info) nothrow on_browser_created;
+
+    ///
+    // Called before a browser is destroyed.
+    ///
+    extern(System) void function (
+        cef_render_process_handler_t* self,
+        cef_browser_t* browser) nothrow on_browser_destroyed;
+
+    ///
+    // Return the handler for browser load status events.
+    ///
+    extern(System) cef_load_handler_t* function (
+        cef_render_process_handler_t* self) nothrow get_load_handler;
+
+    ///
+    // Called immediately after the V8 context for a frame has been created. To
+    // retrieve the JavaScript 'window' object use the
+    // cef_v8context_t::get_global() function. V8 handles can only be accessed
+    // from the thread on which they are created. A task runner for posting tasks
+    // on the associated thread can be retrieved via the
+    // cef_v8context_t::get_task_runner() function.
+    ///
+    extern(System) void function (
+        cef_render_process_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_v8context_t* context) nothrow on_context_created;
+
+    ///
+    // Called immediately before the V8 context for a frame is released. No
+    // references to the context should be kept after this function is called.
+    ///
+    extern(System) void function (
+        cef_render_process_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_v8context_t* context) nothrow on_context_released;
+
+    ///
+    // Called for global uncaught exceptions in a frame. Execution of this
+    // callback is disabled by default. To enable set
+    // CefSettings.uncaught_exception_stack_size > 0.
+    ///
+    extern(System) void function (
+        cef_render_process_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_v8context_t* context,
+        cef_v8exception_t* exception,
+        cef_v8stack_trace_t* stackTrace) nothrow on_uncaught_exception;
+
+    ///
+    // Called when a new node in the the browser gets focus. The |node| value may
+    // be NULL if no specific node has gained focus. The node object passed to
+    // this function represents a snapshot of the DOM at the time this function is
+    // executed. DOM objects are only valid for the scope of this function. Do not
+    // keep references to or attempt to access any DOM objects outside the scope
+    // of this function.
+    ///
+    extern(System) void function (
+        cef_render_process_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_domnode_t* node) nothrow on_focused_node_changed;
+
+    ///
+    // Called when a new message is received from a different process. Return true
+    // (1) if the message was handled or false (0) otherwise. It is safe to keep a
+    // reference to |message| outside of this callback.
+    ///
+    extern(System) int function (
+        cef_render_process_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_process_id_t source_process,
+        cef_process_message_t* message) nothrow on_process_message_received;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_RENDER_PROCESS_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=a5e9055958c3588d583d4d128a5d7c8639f39946$
+//
+
+extern (C):
+
+///
+// Structure used to represent a web request. The functions of this structure
+// may be called on any thread.
+///
+struct cef_request_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is read-only.
+    ///
+    extern(System) int function (cef_request_t* self) nothrow is_read_only;
+
+    ///
+    // Get the fully qualified URL.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_request_t* self) nothrow get_url;
+
+    ///
+    // Set the fully qualified URL.
+    ///
+    extern(System) void function (cef_request_t* self, const(cef_string_t)* url) nothrow set_url;
+
+    ///
+    // Get the request function type. The value will default to POST if post data
+    // is provided and GET otherwise.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_request_t* self) nothrow get_method;
+
+    ///
+    // Set the request function type.
+    ///
+    extern(System) void function (
+        cef_request_t* self,
+        const(cef_string_t)* method) nothrow set_method;
+
+    ///
+    // Set the referrer URL and policy. If non-NULL the referrer URL must be fully
+    // qualified with an HTTP or HTTPS scheme component. Any username, password or
+    // ref component will be removed.
+    ///
+    extern(System) void function (
+        cef_request_t* self,
+        const(cef_string_t)* referrer_url,
+        cef_referrer_policy_t policy) nothrow set_referrer;
+
+    ///
+    // Get the referrer URL.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_request_t* self) nothrow get_referrer_url;
+
+    ///
+    // Get the referrer policy.
+    ///
+    extern(System) cef_referrer_policy_t function (cef_request_t* self) nothrow get_referrer_policy;
+
+    ///
+    // Get the post data.
+    ///
+    extern(System) cef_post_data_t* function (cef_request_t* self) nothrow get_post_data;
+
+    ///
+    // Set the post data.
+    ///
+    extern(System) void function (
+        cef_request_t* self,
+        cef_post_data_t* postData) nothrow set_post_data;
+
+    ///
+    // Get the header values. Will not include the Referer value if any.
+    ///
+    extern(System) void function (
+        cef_request_t* self,
+        cef_string_multimap_t headerMap) nothrow get_header_map;
+
+    ///
+    // Set the header values. If a Referer value exists in the header map it will
+    // be removed and ignored.
+    ///
+    extern(System) void function (
+        cef_request_t* self,
+        cef_string_multimap_t headerMap) nothrow set_header_map;
+
+    ///
+    // Returns the first header value for |name| or an NULL string if not found.
+    // Will not return the Referer value if any. Use GetHeaderMap instead if
+    // |name| might have multiple values.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_request_t* self,
+        const(cef_string_t)* name) nothrow get_header_by_name;
+
+    ///
+    // Set the header |name| to |value|. If |overwrite| is true (1) any existing
+    // values will be replaced with the new value. If |overwrite| is false (0) any
+    // existing values will not be overwritten. The Referer value cannot be set
+    // using this function.
+    ///
+    extern(System) void function (
+        cef_request_t* self,
+        const(cef_string_t)* name,
+        const(cef_string_t)* value,
+        int overwrite) nothrow set_header_by_name;
+
+    ///
+    // Set all values at one time.
+    ///
+    extern(System) void function (
+        cef_request_t* self,
+        const(cef_string_t)* url,
+        const(cef_string_t)* method,
+        cef_post_data_t* postData,
+        cef_string_multimap_t headerMap) nothrow set;
+
+    ///
+    // Get the flags used in combination with cef_urlrequest_t. See
+    // cef_urlrequest_flags_t for supported values.
+    ///
+    extern(System) int function (cef_request_t* self) nothrow get_flags;
+
+    ///
+    // Set the flags used in combination with cef_urlrequest_t.  See
+    // cef_urlrequest_flags_t for supported values.
+    ///
+    extern(System) void function (cef_request_t* self, int flags) nothrow set_flags;
+
+    ///
+    // Get the URL to the first party for cookies used in combination with
+    // cef_urlrequest_t.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_request_t* self) nothrow get_first_party_for_cookies;
+
+    ///
+    // Set the URL to the first party for cookies used in combination with
+    // cef_urlrequest_t.
+    ///
+    extern(System) void function (
+        cef_request_t* self,
+        const(cef_string_t)* url) nothrow set_first_party_for_cookies;
+
+    ///
+    // Get the resource type for this request. Only available in the browser
+    // process.
+    ///
+    extern(System) cef_resource_type_t function (cef_request_t* self) nothrow get_resource_type;
+
+    ///
+    // Get the transition type for this request. Only available in the browser
+    // process and only applies to requests that represent a main frame or sub-
+    // frame navigation.
+    ///
+    extern(System) cef_transition_type_t function (cef_request_t* self) nothrow get_transition_type;
+
+    ///
+    // Returns the globally unique identifier for this request or 0 if not
+    // specified. Can be used by cef_resource_request_handler_t implementations in
+    // the browser process to track a single request across multiple callbacks.
+    ///
+    extern(System) uint64 function (cef_request_t* self) nothrow get_identifier;
+}
+
+
+
+///
+// Create a new cef_request_t object.
+///
+cef_request_t* cef_request_create ();
+
+///
+// Structure used to represent post data for a web request. The functions of
+// this structure may be called on any thread.
+///
+struct cef_post_data_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is read-only.
+    ///
+    extern(System) int function (cef_post_data_t* self) nothrow is_read_only;
+
+    ///
+    // Returns true (1) if the underlying POST data includes elements that are not
+    // represented by this cef_post_data_t object (for example, multi-part file
+    // upload data). Modifying cef_post_data_t objects with excluded elements may
+    // result in the request failing.
+    ///
+    extern(System) int function (cef_post_data_t* self) nothrow has_excluded_elements;
+
+    ///
+    // Returns the number of existing post data elements.
+    ///
+    extern(System) size_t function (cef_post_data_t* self) nothrow get_element_count;
+
+    ///
+    // Retrieve the post data elements.
+    ///
+    extern(System) void function (
+        cef_post_data_t* self,
+        size_t* elementsCount,
+        cef_post_data_element_t** elements) nothrow get_elements;
+
+    ///
+    // Remove the specified post data element.  Returns true (1) if the removal
+    // succeeds.
+    ///
+    extern(System) int function (
+        cef_post_data_t* self,
+        cef_post_data_element_t* element) nothrow remove_element;
+
+    ///
+    // Add the specified post data element.  Returns true (1) if the add succeeds.
+    ///
+    extern(System) int function (
+        cef_post_data_t* self,
+        cef_post_data_element_t* element) nothrow add_element;
+
+    ///
+    // Remove all existing post data elements.
+    ///
+    extern(System) void function (cef_post_data_t* self) nothrow remove_elements;
+}
+
+
+
+///
+// Create a new cef_post_data_t object.
+///
+cef_post_data_t* cef_post_data_create ();
+
+///
+// Structure used to represent a single element in the request post data. The
+// functions of this structure may be called on any thread.
+///
+struct cef_post_data_element_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is read-only.
+    ///
+    extern(System) int function (cef_post_data_element_t* self) nothrow is_read_only;
+
+    ///
+    // Remove all contents from the post data element.
+    ///
+    extern(System) void function (cef_post_data_element_t* self) nothrow set_to_empty;
+
+    ///
+    // The post data element will represent a file.
+    ///
+    extern(System) void function (
+        cef_post_data_element_t* self,
+        const(cef_string_t)* fileName) nothrow set_to_file;
+
+    ///
+    // The post data element will represent bytes.  The bytes passed in will be
+    // copied.
+    ///
+    extern(System) void function (
+        cef_post_data_element_t* self,
+        size_t size,
+        const(void)* bytes) nothrow set_to_bytes;
+
+    ///
+    // Return the type of this post data element.
+    ///
+    extern(System) cef_postdataelement_type_t function (
+        cef_post_data_element_t* self) nothrow get_type;
+
+    ///
+    // Return the file name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_post_data_element_t* self) nothrow get_file;
+
+    ///
+    // Return the number of bytes.
+    ///
+    extern(System) size_t function (cef_post_data_element_t* self) nothrow get_bytes_count;
+
+    ///
+    // Read up to |size| bytes into |bytes| and return the number of bytes
+    // actually read.
+    ///
+    extern(System) size_t function (
+        cef_post_data_element_t* self,
+        size_t size,
+        void* bytes) nothrow get_bytes;
+}
+
+
+
+///
+// Create a new cef_post_data_element_t object.
+///
+cef_post_data_element_t* cef_post_data_element_create ();
+
+// CEF_INCLUDE_CAPI_CEF_REQUEST_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=2e42334fc22050e207e5a0af6fe290a592e4105f$
+//
+
+extern (C):
+
+
+
+
 ///
 // Callback structure for cef_request_context_t::ResolveHost.
 ///
-struct _cef_resolve_callback_t
+struct cef_resolve_callback_t
 {
     ///
     // Base structure.
@@ -18260,13 +13726,13 @@ struct _cef_resolve_callback_t
     // |result| will be the result code. |resolved_ips| will be the list of
     // resolved IP addresses or NULL if the resolution failed.
     ///
-    void function (
-        _cef_resolve_callback_t* self,
+    extern(System) void function (
+        cef_resolve_callback_t* self,
         cef_errorcode_t result,
         cef_string_list_t resolved_ips) nothrow on_resolve_completed;
 }
 
-alias cef_resolve_callback_t = _cef_resolve_callback_t;
+
 
 ///
 // A request context provides request handling for a set of related browser or
@@ -18284,7 +13750,7 @@ alias cef_resolve_callback_t = _cef_resolve_callback_t;
 // first request context passed into a cef_browser_host_t static factory
 // function and all other request context objects will be ignored.
 ///
-struct _cef_request_context_t
+struct cef_request_context_t
 {
     ///
     // Base structure.
@@ -18295,47 +13761,47 @@ struct _cef_request_context_t
     // Returns true (1) if this object is pointing to the same context as |that|
     // object.
     ///
-    int function (
-        _cef_request_context_t* self,
-        _cef_request_context_t* other) nothrow is_same;
+    extern(System) int function (
+        cef_request_context_t* self,
+        cef_request_context_t* other) nothrow is_same;
 
     ///
     // Returns true (1) if this object is sharing the same storage as |that|
     // object.
     ///
-    int function (
-        _cef_request_context_t* self,
-        _cef_request_context_t* other) nothrow is_sharing_with;
+    extern(System) int function (
+        cef_request_context_t* self,
+        cef_request_context_t* other) nothrow is_sharing_with;
 
     ///
     // Returns true (1) if this object is the global context. The global context
     // is used by default when creating a browser or URL request with a NULL
     // context argument.
     ///
-    int function (_cef_request_context_t* self) nothrow is_global;
+    extern(System) int function (cef_request_context_t* self) nothrow is_global;
 
     ///
     // Returns the handler for this context if any.
     ///
-    _cef_request_context_handler_t* function (
-        _cef_request_context_t* self) nothrow get_handler;
+    extern(System) cef_request_context_handler_t* function (
+        cef_request_context_t* self) nothrow get_handler;
 
     ///
     // Returns the cache path for this object. If NULL an "incognito mode" in-
     // memory cache is being used.
     ///
     // The resulting string must be freed by calling cef_string_userfree_free().
-    cef_string_userfree_t function (
-        _cef_request_context_t* self) nothrow get_cache_path;
+    extern(System) cef_string_userfree_t function (
+        cef_request_context_t* self) nothrow get_cache_path;
 
     ///
     // Returns the cookie manager for this object. If |callback| is non-NULL it
-    // will be executed asnychronously on the IO thread after the manager's
+    // will be executed asnychronously on the UI thread after the manager's
     // storage has been initialized.
     ///
-    _cef_cookie_manager_t* function (
-        _cef_request_context_t* self,
-        _cef_completion_callback_t* callback) nothrow get_cookie_manager;
+    extern(System) cef_cookie_manager_t* function (
+        cef_request_context_t* self,
+        cef_completion_callback_t* callback) nothrow get_cookie_manager;
 
     ///
     // Register a scheme handler factory for the specified |scheme_name| and
@@ -18350,17 +13816,17 @@ struct _cef_request_context_t
     // optional |domain_name|. Returns false (0) if an error occurs. This function
     // may be called on any thread in the browser process.
     ///
-    int function (
-        _cef_request_context_t* self,
+    extern(System) int function (
+        cef_request_context_t* self,
         const(cef_string_t)* scheme_name,
         const(cef_string_t)* domain_name,
-        _cef_scheme_handler_factory_t* factory) nothrow register_scheme_handler_factory;
+        cef_scheme_handler_factory_t* factory) nothrow register_scheme_handler_factory;
 
     ///
     // Clear all registered scheme handler factories. Returns false (0) on error.
     // This function may be called on any thread in the browser process.
     ///
-    int function (_cef_request_context_t* self) nothrow clear_scheme_handler_factories;
+    extern(System) int function (cef_request_context_t* self) nothrow clear_scheme_handler_factories;
 
     ///
     // Tells all renderer processes associated with this context to throw away
@@ -18369,16 +13835,16 @@ struct _cef_request_context_t
     // cef_request_context_handler_t::OnBeforePluginLoad may be called to rebuild
     // the plugin list cache.
     ///
-    void function (
-        _cef_request_context_t* self,
+    extern(System) void function (
+        cef_request_context_t* self,
         int reload_pages) nothrow purge_plugin_list_cache;
 
     ///
     // Returns true (1) if a preference with the specified |name| exists. This
     // function must be called on the browser process UI thread.
     ///
-    int function (
-        _cef_request_context_t* self,
+    extern(System) int function (
+        cef_request_context_t* self,
         const(cef_string_t)* name) nothrow has_preference;
 
     ///
@@ -18388,8 +13854,8 @@ struct _cef_request_context_t
     // will not modify the underlying preference value. This function must be
     // called on the browser process UI thread.
     ///
-    _cef_value_t* function (
-        _cef_request_context_t* self,
+    extern(System) cef_value_t* function (
+        cef_request_context_t* self,
         const(cef_string_t)* name) nothrow get_preference;
 
     ///
@@ -18400,8 +13866,8 @@ struct _cef_request_context_t
     // preference values. This function must be called on the browser process UI
     // thread.
     ///
-    _cef_dictionary_value_t* function (
-        _cef_request_context_t* self,
+    extern(System) cef_dictionary_value_t* function (
+        cef_request_context_t* self,
         int include_defaults) nothrow get_all_preferences;
 
     ///
@@ -18410,8 +13876,8 @@ struct _cef_request_context_t
     // command-line usually cannot be modified. This function must be called on
     // the browser process UI thread.
     ///
-    int function (
-        _cef_request_context_t* self,
+    extern(System) int function (
+        cef_request_context_t* self,
         const(cef_string_t)* name) nothrow can_set_preference;
 
     ///
@@ -18421,10 +13887,10 @@ struct _cef_request_context_t
     // fails then |error| will be populated with a detailed description of the
     // problem. This function must be called on the browser process UI thread.
     ///
-    int function (
-        _cef_request_context_t* self,
+    extern(System) int function (
+        cef_request_context_t* self,
         const(cef_string_t)* name,
-        _cef_value_t* value,
+        cef_value_t* value,
         cef_string_t* error) nothrow set_preference;
 
     ///
@@ -18435,18 +13901,18 @@ struct _cef_request_context_t
     // |callback| is non-NULL it will be executed on the UI thread after
     // completion.
     ///
-    void function (
-        _cef_request_context_t* self,
-        _cef_completion_callback_t* callback) nothrow clear_certificate_exceptions;
+    extern(System) void function (
+        cef_request_context_t* self,
+        cef_completion_callback_t* callback) nothrow clear_certificate_exceptions;
 
     ///
     // Clears all HTTP authentication credentials that were added as part of
     // handling GetAuthCredentials. If |callback| is non-NULL it will be executed
     // on the UI thread after completion.
     ///
-    void function (
-        _cef_request_context_t* self,
-        _cef_completion_callback_t* callback) nothrow clear_http_auth_credentials;
+    extern(System) void function (
+        cef_request_context_t* self,
+        cef_completion_callback_t* callback) nothrow clear_http_auth_credentials;
 
     ///
     // Clears all active and idle connections that Chromium currently has. This is
@@ -18454,18 +13920,18 @@ struct _cef_request_context_t
     // want to call cef_shutdown(). If |callback| is non-NULL it will be executed
     // on the UI thread after completion.
     ///
-    void function (
-        _cef_request_context_t* self,
-        _cef_completion_callback_t* callback) nothrow close_all_connections;
+    extern(System) void function (
+        cef_request_context_t* self,
+        cef_completion_callback_t* callback) nothrow close_all_connections;
 
     ///
     // Attempts to resolve |origin| to a list of associated IP addresses.
     // |callback| will be executed on the UI thread after completion.
     ///
-    void function (
-        _cef_request_context_t* self,
+    extern(System) void function (
+        cef_request_context_t* self,
         const(cef_string_t)* origin,
-        _cef_resolve_callback_t* callback) nothrow resolve_host;
+        cef_resolve_callback_t* callback) nothrow resolve_host;
 
     ///
     // Load an extension.
@@ -18515,11 +13981,11 @@ struct _cef_request_context_t
     // See https://developer.chrome.com/extensions for extension implementation
     // and usage documentation.
     ///
-    void function (
-        _cef_request_context_t* self,
+    extern(System) void function (
+        cef_request_context_t* self,
         const(cef_string_t)* root_directory,
-        _cef_dictionary_value_t* manifest,
-        _cef_extension_handler_t* handler) nothrow load_extension;
+        cef_dictionary_value_t* manifest,
+        cef_extension_handler_t* handler) nothrow load_extension;
 
     ///
     // Returns true (1) if this context was used to load the extension identified
@@ -18527,8 +13993,8 @@ struct _cef_request_context_t
     // access to the extension (see HasExtension). This function must be called on
     // the browser process UI thread.
     ///
-    int function (
-        _cef_request_context_t* self,
+    extern(System) int function (
+        cef_request_context_t* self,
         const(cef_string_t)* extension_id) nothrow did_load_extension;
 
     ///
@@ -18537,8 +14003,8 @@ struct _cef_request_context_t
     // extension (see DidLoadExtension). This function must be called on the
     // browser process UI thread.
     ///
-    int function (
-        _cef_request_context_t* self,
+    extern(System) int function (
+        cef_request_context_t* self,
         const(cef_string_t)* extension_id) nothrow has_extension;
 
     ///
@@ -18547,8 +14013,8 @@ struct _cef_request_context_t
     // ID values. Returns true (1) on success. This function must be called on the
     // browser process UI thread.
     ///
-    int function (
-        _cef_request_context_t* self,
+    extern(System) int function (
+        cef_request_context_t* self,
         cef_string_list_t extension_ids) nothrow get_extensions;
 
     ///
@@ -18556,18 +14022,21 @@ struct _cef_request_context_t
     // extension is accessible in this context (see HasExtension). This function
     // must be called on the browser process UI thread.
     ///
-    _cef_extension_t* function (
-        _cef_request_context_t* self,
+    extern(System) cef_extension_t* function (
+        cef_request_context_t* self,
         const(cef_string_t)* extension_id) nothrow get_extension;
 
     ///
-    // Returns the MediaRouter object associated with this context.
+    // Returns the MediaRouter object associated with this context.  If |callback|
+    // is non-NULL it will be executed asnychronously on the UI thread after the
+    // manager's context has been initialized.
     ///
-    _cef_media_router_t* function (
-        _cef_request_context_t* self) nothrow get_media_router;
+    extern(System) cef_media_router_t* function (
+        cef_request_context_t* self,
+        cef_completion_callback_t* callback) nothrow get_media_router;
 }
 
-alias cef_request_context_t = _cef_request_context_t;
+
 
 ///
 // Returns the global context object.
@@ -18579,8 +14048,8 @@ cef_request_context_t* cef_request_context_get_global_context ();
 // |handler|.
 ///
 cef_request_context_t* cef_request_context_create_context (
-    const(_cef_request_context_settings_t)* settings,
-    _cef_request_context_handler_t* handler);
+    const(cef_request_context_settings_t)* settings,
+    cef_request_context_handler_t* handler);
 
 ///
 // Creates a new context object that shares storage with |other| and uses an
@@ -18588,10 +14057,10 @@ cef_request_context_t* cef_request_context_create_context (
 ///
 cef_request_context_t* cef_create_context_shared (
     cef_request_context_t* other,
-    _cef_request_context_handler_t* handler);
+    cef_request_context_handler_t* handler);
 
 // CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_CAPI_H_
-// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved.
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -18626,18 +14095,17 @@ cef_request_context_t* cef_create_context_shared (
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=a13b5b607d5a2108fac5fe75f5ebd2ede7eaef6a$
+// $hash=fa148db8a0ecd79966814086fb92e439687be701$
 //
 
 extern (C):
 
-//#include "include/capi/cef_browser_capi.h"
-
 ///
-// Callback structure used for asynchronous continuation of
-// cef_extension_handler_t::GetExtensionResource.
+// Implement this structure to provide handler implementations. The handler
+// instance will not be released until all objects related to the context have
+// been destroyed.
 ///
-struct _cef_get_extension_resource_callback_t
+struct cef_request_context_handler_t
 {
     ///
     // Base structure.
@@ -18645,26 +14113,2656 @@ struct _cef_get_extension_resource_callback_t
     cef_base_ref_counted_t base;
 
     ///
-    // Continue the request. Read the resource contents from |stream|.
+    // Called on the browser process UI thread immediately after the request
+    // context has been initialized.
     ///
-    void function (
-        _cef_get_extension_resource_callback_t* self,
-        _cef_stream_reader_t* stream) nothrow cont;
+    extern(System) void function (
+        cef_request_context_handler_t* self,
+        cef_request_context_t* request_context) nothrow on_request_context_initialized;
+
+    ///
+    // Called on multiple browser process threads before a plugin instance is
+    // loaded. |mime_type| is the mime type of the plugin that will be loaded.
+    // |plugin_url| is the content URL that the plugin will load and may be NULL.
+    // |is_main_frame| will be true (1) if the plugin is being loaded in the main
+    // (top-level) frame, |top_origin_url| is the URL for the top-level frame that
+    // contains the plugin when loading a specific plugin instance or NULL when
+    // building the initial list of enabled plugins for 'navigator.plugins'
+    // JavaScript state. |plugin_info| includes additional information about the
+    // plugin that will be loaded. |plugin_policy| is the recommended policy.
+    // Modify |plugin_policy| and return true (1) to change the policy. Return
+    // false (0) to use the recommended policy. The default plugin policy can be
+    // set at runtime using the `--plugin-policy=[allow|detect|block]` command-
+    // line flag. Decisions to mark a plugin as disabled by setting
+    // |plugin_policy| to PLUGIN_POLICY_DISABLED may be cached when
+    // |top_origin_url| is NULL. To purge the plugin list cache and potentially
+    // trigger new calls to this function call
+    // cef_request_context_t::PurgePluginListCache.
+    ///
+    extern(System) int function (
+        cef_request_context_handler_t* self,
+        const(cef_string_t)* mime_type,
+        const(cef_string_t)* plugin_url,
+        int is_main_frame,
+        const(cef_string_t)* top_origin_url,
+        cef_web_plugin_info_t* plugin_info,
+        cef_plugin_policy_t* plugin_policy) nothrow on_before_plugin_load;
+
+    ///
+    // Called on the browser process IO thread before a resource request is
+    // initiated. The |browser| and |frame| values represent the source of the
+    // request, and may be NULL for requests originating from service workers or
+    // cef_urlrequest_t. |request| represents the request contents and cannot be
+    // modified in this callback. |is_navigation| will be true (1) if the resource
+    // request is a navigation. |is_download| will be true (1) if the resource
+    // request is a download. |request_initiator| is the origin (scheme + domain)
+    // of the page that initiated the request. Set |disable_default_handling| to
+    // true (1) to disable default handling of the request, in which case it will
+    // need to be handled via cef_resource_request_handler_t::GetResourceHandler
+    // or it will be canceled. To allow the resource load to proceed with default
+    // handling return NULL. To specify a handler for the resource return a
+    // cef_resource_request_handler_t object. This function will not be called if
+    // the client associated with |browser| returns a non-NULL value from
+    // cef_request_handler_t::GetResourceRequestHandler for the same request
+    // (identified by cef_request_t::GetIdentifier).
+    ///
+    extern(System) cef_resource_request_handler_t* function (
+        cef_request_context_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        int is_navigation,
+        int is_download,
+        const(cef_string_t)* request_initiator,
+        int* disable_default_handling) nothrow get_resource_request_handler;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_REQUEST_CONTEXT_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=83ff671e8a4db001029be8a02a414333fe4354af$
+//
+
+extern (C):
+
+///
+// Callback structure used to select a client certificate for authentication.
+///
+struct cef_select_client_certificate_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Chooses the specified certificate for client certificate authentication.
+    // NULL value means that no client certificate should be used.
+    ///
+    extern(System) void function (
+        cef_select_client_certificate_callback_t* self,
+        cef_x509certificate_t* cert) nothrow select;
+}
+
+
+
+///
+// Implement this structure to handle events related to browser requests. The
+// functions of this structure will be called on the thread indicated.
+///
+struct cef_request_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called on the UI thread before browser navigation. Return true (1) to
+    // cancel the navigation or false (0) to allow the navigation to proceed. The
+    // |request| object cannot be modified in this callback.
+    // cef_load_handler_t::OnLoadingStateChange will be called twice in all cases.
+    // If the navigation is allowed cef_load_handler_t::OnLoadStart and
+    // cef_load_handler_t::OnLoadEnd will be called. If the navigation is canceled
+    // cef_load_handler_t::OnLoadError will be called with an |errorCode| value of
+    // ERR_ABORTED. The |user_gesture| value will be true (1) if the browser
+    // navigated via explicit user gesture (e.g. clicking a link) or false (0) if
+    // it navigated automatically (e.g. via the DomContentLoaded event).
+    ///
+    extern(System) int function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        int user_gesture,
+        int is_redirect) nothrow on_before_browse;
+
+    ///
+    // Called on the UI thread before OnBeforeBrowse in certain limited cases
+    // where navigating a new or different browser might be desirable. This
+    // includes user-initiated navigation that might open in a special way (e.g.
+    // links clicked via middle-click or ctrl + left-click) and certain types of
+    // cross-origin navigation initiated from the renderer process (e.g.
+    // navigating the top-level frame to/from a file URL). The |browser| and
+    // |frame| values represent the source of the navigation. The
+    // |target_disposition| value indicates where the user intended to navigate
+    // the browser based on standard Chromium behaviors (e.g. current tab, new
+    // tab, etc). The |user_gesture| value will be true (1) if the browser
+    // navigated via explicit user gesture (e.g. clicking a link) or false (0) if
+    // it navigated automatically (e.g. via the DomContentLoaded event). Return
+    // true (1) to cancel the navigation or false (0) to allow the navigation to
+    // proceed in the source browser's top-level frame.
+    ///
+    extern(System) int function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        const(cef_string_t)* target_url,
+        cef_window_open_disposition_t target_disposition,
+        int user_gesture) nothrow on_open_urlfrom_tab;
+
+    ///
+    // Called on the browser process IO thread before a resource request is
+    // initiated. The |browser| and |frame| values represent the source of the
+    // request. |request| represents the request contents and cannot be modified
+    // in this callback. |is_navigation| will be true (1) if the resource request
+    // is a navigation. |is_download| will be true (1) if the resource request is
+    // a download. |request_initiator| is the origin (scheme + domain) of the page
+    // that initiated the request. Set |disable_default_handling| to true (1) to
+    // disable default handling of the request, in which case it will need to be
+    // handled via cef_resource_request_handler_t::GetResourceHandler or it will
+    // be canceled. To allow the resource load to proceed with default handling
+    // return NULL. To specify a handler for the resource return a
+    // cef_resource_request_handler_t object. If this callback returns NULL the
+    // same function will be called on the associated
+    // cef_request_context_handler_t, if any.
+    ///
+    extern(System) cef_resource_request_handler_t* function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        int is_navigation,
+        int is_download,
+        const(cef_string_t)* request_initiator,
+        int* disable_default_handling) nothrow get_resource_request_handler;
+
+    ///
+    // Called on the IO thread when the browser needs credentials from the user.
+    // |origin_url| is the origin making this authentication request. |isProxy|
+    // indicates whether the host is a proxy server. |host| contains the hostname
+    // and |port| contains the port number. |realm| is the realm of the challenge
+    // and may be NULL. |scheme| is the authentication scheme used, such as
+    // "basic" or "digest", and will be NULL if the source of the request is an
+    // FTP server. Return true (1) to continue the request and call
+    // cef_auth_callback_t::cont() either in this function or at a later time when
+    // the authentication information is available. Return false (0) to cancel the
+    // request immediately.
+    ///
+    extern(System) int function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* origin_url,
+        int isProxy,
+        const(cef_string_t)* host,
+        int port,
+        const(cef_string_t)* realm,
+        const(cef_string_t)* scheme,
+        cef_auth_callback_t* callback) nothrow get_auth_credentials;
+
+    ///
+    // Called on the IO thread when JavaScript requests a specific storage quota
+    // size via the webkitStorageInfo.requestQuota function. |origin_url| is the
+    // origin of the page making the request. |new_size| is the requested quota
+    // size in bytes. Return true (1) to continue the request and call
+    // cef_callback_t functions either in this function or at a later time to
+    // grant or deny the request. Return false (0) to cancel the request
+    // immediately.
+    ///
+    extern(System) int function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* origin_url,
+        int64 new_size,
+        cef_callback_t* callback) nothrow on_quota_request;
+
+    ///
+    // Called on the UI thread to handle requests for URLs with an invalid SSL
+    // certificate. Return true (1) and call cef_callback_t functions either in
+    // this function or at a later time to continue or cancel the request. Return
+    // false (0) to cancel the request immediately. If
+    // CefSettings.ignore_certificate_errors is set all invalid certificates will
+    // be accepted without calling this function.
+    ///
+    extern(System) int function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_errorcode_t cert_error,
+        const(cef_string_t)* request_url,
+        cef_sslinfo_t* ssl_info,
+        cef_callback_t* callback) nothrow on_certificate_error;
+
+    ///
+    // Called on the UI thread when a client certificate is being requested for
+    // authentication. Return false (0) to use the default behavior and
+    // automatically select the first certificate available. Return true (1) and
+    // call cef_select_client_certificate_callback_t::Select either in this
+    // function or at a later time to select a certificate. Do not call Select or
+    // call it with NULL to continue without using any certificate. |isProxy|
+    // indicates whether the host is an HTTPS proxy or the origin server. |host|
+    // and |port| contains the hostname and port of the SSL server. |certificates|
+    // is the list of certificates to choose from; this list has already been
+    // pruned by Chromium so that it only contains certificates from issuers that
+    // the server trusts.
+    ///
+    extern(System) int function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser,
+        int isProxy,
+        const(cef_string_t)* host,
+        int port,
+        size_t certificatesCount,
+        cef_x509certificate_t** certificates,
+        cef_select_client_certificate_callback_t* callback) nothrow on_select_client_certificate;
+
+    ///
+    // Called on the browser process UI thread when a plugin has crashed.
+    // |plugin_path| is the path of the plugin that crashed.
+    ///
+    extern(System) void function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser,
+        const(cef_string_t)* plugin_path) nothrow on_plugin_crashed;
+
+    ///
+    // Called on the browser process UI thread when the render view associated
+    // with |browser| is ready to receive/handle IPC messages in the render
+    // process.
+    ///
+    extern(System) void function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser) nothrow on_render_view_ready;
+
+    ///
+    // Called on the browser process UI thread when the render process terminates
+    // unexpectedly. |status| indicates how the process terminated.
+    ///
+    extern(System) void function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_termination_status_t status) nothrow on_render_process_terminated;
+
+    ///
+    // Called on the browser process UI thread when the window.document object of
+    // the main frame has been created.
+    ///
+    extern(System) void function (
+        cef_request_handler_t* self,
+        cef_browser_t* browser) nothrow on_document_available_in_main_frame;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_REQUEST_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=ffe0de3b50e0a612bd1b055b873c265b030e721d$
+//
+
+extern (C):
+
+///
+// Structure used for retrieving resources from the resource bundle (*.pak)
+// files loaded by CEF during startup or via the cef_resource_bundle_handler_t
+// returned from cef_app_t::GetResourceBundleHandler. See CefSettings for
+// additional options related to resource bundle loading. The functions of this
+// structure may be called on any thread unless otherwise indicated.
+///
+struct cef_resource_bundle_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the localized string for the specified |string_id| or an NULL
+    // string if the value is not found. Include cef_pack_strings.h for a listing
+    // of valid string ID values.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_resource_bundle_t* self,
+        int string_id) nothrow get_localized_string;
+
+    ///
+    // Returns a cef_binary_value_t containing the decompressed contents of the
+    // specified scale independent |resource_id| or NULL if not found. Include
+    // cef_pack_resources.h for a listing of valid resource ID values.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_resource_bundle_t* self,
+        int resource_id) nothrow get_data_resource;
+
+    ///
+    // Returns a cef_binary_value_t containing the decompressed contents of the
+    // specified |resource_id| nearest the scale factor |scale_factor| or NULL if
+    // not found. Use a |scale_factor| value of SCALE_FACTOR_NONE for scale
+    // independent resources or call GetDataResource instead.Include
+    // cef_pack_resources.h for a listing of valid resource ID values.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_resource_bundle_t* self,
+        int resource_id,
+        cef_scale_factor_t scale_factor) nothrow get_data_resource_for_scale;
+}
+
+
+
+///
+// Returns the global resource bundle instance.
+///
+cef_resource_bundle_t* cef_resource_bundle_get_global ();
+
+// CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=b9723e0dfe6d03c24665eac2264396743a5254df$
+//
+
+extern (C):
+
+///
+// Structure used to implement a custom resource bundle structure. See
+// CefSettings for additional options related to resource bundle loading. The
+// functions of this structure may be called on multiple threads.
+///
+struct cef_resource_bundle_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called to retrieve a localized translation for the specified |string_id|.
+    // To provide the translation set |string| to the translation string and
+    // return true (1). To use the default translation return false (0). Include
+    // cef_pack_strings.h for a listing of valid string ID values.
+    ///
+    extern(System) int function (
+        cef_resource_bundle_handler_t* self,
+        int string_id,
+        cef_string_t* string) nothrow get_localized_string;
+
+    ///
+    // Called to retrieve data for the specified scale independent |resource_id|.
+    // To provide the resource data set |data| and |data_size| to the data pointer
+    // and size respectively and return true (1). To use the default resource data
+    // return false (0). The resource data will not be copied and must remain
+    // resident in memory. Include cef_pack_resources.h for a listing of valid
+    // resource ID values.
+    ///
+    extern(System) int function (
+        cef_resource_bundle_handler_t* self,
+        int resource_id,
+        void** data,
+        size_t* data_size) nothrow get_data_resource;
+
+    ///
+    // Called to retrieve data for the specified |resource_id| nearest the scale
+    // factor |scale_factor|. To provide the resource data set |data| and
+    // |data_size| to the data pointer and size respectively and return true (1).
+    // To use the default resource data return false (0). The resource data will
+    // not be copied and must remain resident in memory. Include
+    // cef_pack_resources.h for a listing of valid resource ID values.
+    ///
+    extern(System) int function (
+        cef_resource_bundle_handler_t* self,
+        int resource_id,
+        cef_scale_factor_t scale_factor,
+        void** data,
+        size_t* data_size) nothrow get_data_resource_for_scale;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_RESOURCE_BUNDLE_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=a9598f4e94a864e749b425aa62bc519589f5753e$
+//
+
+extern (C):
+
+///
+// Callback for asynchronous continuation of cef_resource_handler_t::skip().
+///
+struct cef_resource_skip_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Callback for asynchronous continuation of skip(). If |bytes_skipped| > 0
+    // then either skip() will be called again until the requested number of bytes
+    // have been skipped or the request will proceed. If |bytes_skipped| <= 0 the
+    // request will fail with ERR_REQUEST_RANGE_NOT_SATISFIABLE.
+    ///
+    extern(System) void function (
+        cef_resource_skip_callback_t* self,
+        int64 bytes_skipped) nothrow cont;
+}
+
+
+
+///
+// Callback for asynchronous continuation of cef_resource_handler_t::read().
+///
+struct cef_resource_read_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Callback for asynchronous continuation of read(). If |bytes_read| == 0 the
+    // response will be considered complete. If |bytes_read| > 0 then read() will
+    // be called again until the request is complete (based on either the result
+    // or the expected content length). If |bytes_read| < 0 then the request will
+    // fail and the |bytes_read| value will be treated as the error code.
+    ///
+    extern(System) void function (cef_resource_read_callback_t* self, int bytes_read) nothrow cont;
+}
+
+
+
+///
+// Structure used to implement a custom request handler structure. The functions
+// of this structure will be called on the IO thread unless otherwise indicated.
+///
+struct cef_resource_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Open the response stream. To handle the request immediately set
+    // |handle_request| to true (1) and return true (1). To decide at a later time
+    // set |handle_request| to false (0), return true (1), and execute |callback|
+    // to continue or cancel the request. To cancel the request immediately set
+    // |handle_request| to true (1) and return false (0). This function will be
+    // called in sequence but not from a dedicated thread. For backwards
+    // compatibility set |handle_request| to false (0) and return false (0) and
+    // the ProcessRequest function will be called.
+    ///
+    extern(System) int function (
+        cef_resource_handler_t* self,
+        cef_request_t* request,
+        int* handle_request,
+        cef_callback_t* callback) nothrow open;
+
+    ///
+    // Begin processing the request. To handle the request return true (1) and
+    // call cef_callback_t::cont() once the response header information is
+    // available (cef_callback_t::cont() can also be called from inside this
+    // function if header information is available immediately). To cancel the
+    // request return false (0).
+    //
+    // WARNING: This function is deprecated. Use Open instead.
+    ///
+    extern(System) int function (
+        cef_resource_handler_t* self,
+        cef_request_t* request,
+        cef_callback_t* callback) nothrow process_request;
+
+    ///
+    // Retrieve response header information. If the response length is not known
+    // set |response_length| to -1 and read_response() will be called until it
+    // returns false (0). If the response length is known set |response_length| to
+    // a positive value and read_response() will be called until it returns false
+    // (0) or the specified number of bytes have been read. Use the |response|
+    // object to set the mime type, http status code and other optional header
+    // values. To redirect the request to a new URL set |redirectUrl| to the new
+    // URL. |redirectUrl| can be either a relative or fully qualified URL. It is
+    // also possible to set |response| to a redirect http status code and pass the
+    // new URL via a Location header. Likewise with |redirectUrl| it is valid to
+    // set a relative or fully qualified URL as the Location header value. If an
+    // error occured while setting up the request you can call set_error() on
+    // |response| to indicate the error condition.
+    ///
+    extern(System) void function (
+        cef_resource_handler_t* self,
+        cef_response_t* response,
+        int64* response_length,
+        cef_string_t* redirectUrl) nothrow get_response_headers;
+
+    ///
+    // Skip response data when requested by a Range header. Skip over and discard
+    // |bytes_to_skip| bytes of response data. If data is available immediately
+    // set |bytes_skipped| to the number of bytes skipped and return true (1). To
+    // read the data at a later time set |bytes_skipped| to 0, return true (1) and
+    // execute |callback| when the data is available. To indicate failure set
+    // |bytes_skipped| to < 0 (e.g. -2 for ERR_FAILED) and return false (0). This
+    // function will be called in sequence but not from a dedicated thread.
+    ///
+    extern(System) int function (
+        cef_resource_handler_t* self,
+        int64 bytes_to_skip,
+        int64* bytes_skipped,
+        cef_resource_skip_callback_t* callback) nothrow skip;
+
+    ///
+    // Read response data. If data is available immediately copy up to
+    // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
+    // bytes copied, and return true (1). To read the data at a later time keep a
+    // pointer to |data_out|, set |bytes_read| to 0, return true (1) and execute
+    // |callback| when the data is available (|data_out| will remain valid until
+    // the callback is executed). To indicate response completion set |bytes_read|
+    // to 0 and return false (0). To indicate failure set |bytes_read| to < 0
+    // (e.g. -2 for ERR_FAILED) and return false (0). This function will be called
+    // in sequence but not from a dedicated thread. For backwards compatibility
+    // set |bytes_read| to -1 and return false (0) and the ReadResponse function
+    // will be called.
+    ///
+    extern(System) int function (
+        cef_resource_handler_t* self,
+        void* data_out,
+        int bytes_to_read,
+        int* bytes_read,
+        cef_resource_read_callback_t* callback) nothrow read;
+
+    ///
+    // Read response data. If data is available immediately copy up to
+    // |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
+    // bytes copied, and return true (1). To read the data at a later time set
+    // |bytes_read| to 0, return true (1) and call cef_callback_t::cont() when the
+    // data is available. To indicate response completion return false (0).
+    //
+    // WARNING: This function is deprecated. Use Skip and Read instead.
+    ///
+    extern(System) int function (
+        cef_resource_handler_t* self,
+        void* data_out,
+        int bytes_to_read,
+        int* bytes_read,
+        cef_callback_t* callback) nothrow read_response;
+
+    ///
+    // Request processing has been canceled.
+    ///
+    extern(System) void function (cef_resource_handler_t* self) nothrow cancel;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_RESOURCE_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=7276396521b8b61cf856050244f558baa3a52e04$
+//
+
+extern (C):
+
+///
+// Implement this structure to handle events related to browser requests. The
+// functions of this structure will be called on the IO thread unless otherwise
+// indicated.
+///
+struct cef_resource_request_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called on the IO thread before a resource request is loaded. The |browser|
+    // and |frame| values represent the source of the request, and may be NULL for
+    // requests originating from service workers or cef_urlrequest_t. To
+    // optionally filter cookies for the request return a
+    // cef_cookie_access_filter_t object. The |request| object cannot not be
+    // modified in this callback.
+    ///
+    extern(System) cef_cookie_access_filter_t* function (
+        cef_resource_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request) nothrow get_cookie_access_filter;
+
+    ///
+    // Called on the IO thread before a resource request is loaded. The |browser|
+    // and |frame| values represent the source of the request, and may be NULL for
+    // requests originating from service workers or cef_urlrequest_t. To redirect
+    // or change the resource load optionally modify |request|. Modification of
+    // the request URL will be treated as a redirect. Return RV_CONTINUE to
+    // continue the request immediately. Return RV_CONTINUE_ASYNC and call
+    // cef_callback_t functions at a later time to continue or cancel the request
+    // asynchronously. Return RV_CANCEL to cancel the request immediately.
+    //
+    ///
+    extern(System) cef_return_value_t function (
+        cef_resource_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        cef_callback_t* callback) nothrow on_before_resource_load;
+
+    ///
+    // Called on the IO thread before a resource is loaded. The |browser| and
+    // |frame| values represent the source of the request, and may be NULL for
+    // requests originating from service workers or cef_urlrequest_t. To allow the
+    // resource to load using the default network loader return NULL. To specify a
+    // handler for the resource return a cef_resource_handler_t object. The
+    // |request| object cannot not be modified in this callback.
+    ///
+    extern(System) cef_resource_handler_t* function (
+        cef_resource_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request) nothrow get_resource_handler;
+
+    ///
+    // Called on the IO thread when a resource load is redirected. The |browser|
+    // and |frame| values represent the source of the request, and may be NULL for
+    // requests originating from service workers or cef_urlrequest_t. The
+    // |request| parameter will contain the old URL and other request-related
+    // information. The |response| parameter will contain the response that
+    // resulted in the redirect. The |new_url| parameter will contain the new URL
+    // and can be changed if desired. The |request| and |response| objects cannot
+    // be modified in this callback.
+    ///
+    extern(System) void function (
+        cef_resource_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        cef_response_t* response,
+        cef_string_t* new_url) nothrow on_resource_redirect;
+
+    ///
+    // Called on the IO thread when a resource response is received. The |browser|
+    // and |frame| values represent the source of the request, and may be NULL for
+    // requests originating from service workers or cef_urlrequest_t. To allow the
+    // resource load to proceed without modification return false (0). To redirect
+    // or retry the resource load optionally modify |request| and return true (1).
+    // Modification of the request URL will be treated as a redirect. Requests
+    // handled using the default network loader cannot be redirected in this
+    // callback. The |response| object cannot be modified in this callback.
+    //
+    // WARNING: Redirecting using this function is deprecated. Use
+    // OnBeforeResourceLoad or GetResourceHandler to perform redirects.
+    ///
+    extern(System) int function (
+        cef_resource_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        cef_response_t* response) nothrow on_resource_response;
+
+    ///
+    // Called on the IO thread to optionally filter resource response content. The
+    // |browser| and |frame| values represent the source of the request, and may
+    // be NULL for requests originating from service workers or cef_urlrequest_t.
+    // |request| and |response| represent the request and response respectively
+    // and cannot be modified in this callback.
+    ///
+    extern(System) cef_response_filter_t* function (
+        cef_resource_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        cef_response_t* response) nothrow get_resource_response_filter;
+
+    ///
+    // Called on the IO thread when a resource load has completed. The |browser|
+    // and |frame| values represent the source of the request, and may be NULL for
+    // requests originating from service workers or cef_urlrequest_t. |request|
+    // and |response| represent the request and response respectively and cannot
+    // be modified in this callback. |status| indicates the load completion
+    // status. |received_content_length| is the number of response bytes actually
+    // read. This function will be called for all requests, including requests
+    // that are aborted due to CEF shutdown or destruction of the associated
+    // browser. In cases where the associated browser is destroyed this callback
+    // may arrive after the cef_life_span_handler_t::OnBeforeClose callback for
+    // that browser. The cef_frame_t::IsValid function can be used to test for
+    // this situation, and care should be taken not to call |browser| or |frame|
+    // functions that modify state (like LoadURL, SendProcessMessage, etc.) if the
+    // frame is invalid.
+    ///
+    extern(System) void function (
+        cef_resource_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        cef_response_t* response,
+        cef_urlrequest_status_t status,
+        int64 received_content_length) nothrow on_resource_load_complete;
+
+    ///
+    // Called on the IO thread to handle requests for URLs with an unknown
+    // protocol component. The |browser| and |frame| values represent the source
+    // of the request, and may be NULL for requests originating from service
+    // workers or cef_urlrequest_t. |request| cannot be modified in this callback.
+    // Set |allow_os_execution| to true (1) to attempt execution via the
+    // registered OS protocol handler, if any. SECURITY WARNING: YOU SHOULD USE
+    // THIS METHOD TO ENFORCE RESTRICTIONS BASED ON SCHEME, HOST OR OTHER URL
+    // ANALYSIS BEFORE ALLOWING OS EXECUTION.
+    ///
+    extern(System) void function (
+        cef_resource_request_handler_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        int* allow_os_execution) nothrow on_protocol_execution;
+}
+
+
+
+///
+// Implement this structure to filter cookies that may be sent or received from
+// resource requests. The functions of this structure will be called on the IO
+// thread unless otherwise indicated.
+///
+struct cef_cookie_access_filter_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called on the IO thread before a resource request is sent. The |browser|
+    // and |frame| values represent the source of the request, and may be NULL for
+    // requests originating from service workers or cef_urlrequest_t. |request|
+    // cannot be modified in this callback. Return true (1) if the specified
+    // cookie can be sent with the request or false (0) otherwise.
+    ///
+    extern(System) int function (
+        cef_cookie_access_filter_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        const(cef_cookie_t)* cookie) nothrow can_send_cookie;
+
+    ///
+    // Called on the IO thread after a resource response is received. The
+    // |browser| and |frame| values represent the source of the request, and may
+    // be NULL for requests originating from service workers or cef_urlrequest_t.
+    // |request| cannot be modified in this callback. Return true (1) if the
+    // specified cookie returned with the response can be saved or false (0)
+    // otherwise.
+    ///
+    extern(System) int function (
+        cef_cookie_access_filter_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        cef_request_t* request,
+        cef_response_t* response,
+        const(cef_cookie_t)* cookie) nothrow can_save_cookie;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_RESOURCE_REQUEST_HANDLER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=8202bbf8e7f7ae474182c483f0f599b13f6914eb$
+//
+
+extern (C):
+
+///
+// Structure used to represent a web response. The functions of this structure
+// may be called on any thread.
+///
+struct cef_response_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is read-only.
+    ///
+    extern(System) int function (cef_response_t* self) nothrow is_read_only;
+
+    ///
+    // Get the response error code. Returns ERR_NONE if there was no error.
+    ///
+    extern(System) cef_errorcode_t function (cef_response_t* self) nothrow get_error;
+
+    ///
+    // Set the response error code. This can be used by custom scheme handlers to
+    // return errors during initial request processing.
+    ///
+    extern(System) void function (cef_response_t* self, cef_errorcode_t error) nothrow set_error;
+
+    ///
+    // Get the response status code.
+    ///
+    extern(System) int function (cef_response_t* self) nothrow get_status;
+
+    ///
+    // Set the response status code.
+    ///
+    extern(System) void function (cef_response_t* self, int status) nothrow set_status;
+
+    ///
+    // Get the response status text.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_response_t* self) nothrow get_status_text;
+
+    ///
+    // Set the response status text.
+    ///
+    extern(System) void function (
+        cef_response_t* self,
+        const(cef_string_t)* statusText) nothrow set_status_text;
+
+    ///
+    // Get the response mime type.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_response_t* self) nothrow get_mime_type;
+
+    ///
+    // Set the response mime type.
+    ///
+    extern(System) void function (
+        cef_response_t* self,
+        const(cef_string_t)* mimeType) nothrow set_mime_type;
+
+    ///
+    // Get the response charset.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_response_t* self) nothrow get_charset;
+
+    ///
+    // Set the response charset.
+    ///
+    extern(System) void function (
+        cef_response_t* self,
+        const(cef_string_t)* charset) nothrow set_charset;
+
+    ///
+    // Get the value for the specified response header field.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_response_t* self,
+        const(cef_string_t)* name) nothrow get_header_by_name;
+
+    ///
+    // Set the header |name| to |value|. If |overwrite| is true (1) any existing
+    // values will be replaced with the new value. If |overwrite| is false (0) any
+    // existing values will not be overwritten.
+    ///
+    extern(System) void function (
+        cef_response_t* self,
+        const(cef_string_t)* name,
+        const(cef_string_t)* value,
+        int overwrite) nothrow set_header_by_name;
+
+    ///
+    // Get all response header fields.
+    ///
+    extern(System) void function (
+        cef_response_t* self,
+        cef_string_multimap_t headerMap) nothrow get_header_map;
+
+    ///
+    // Set all response header fields.
+    ///
+    extern(System) void function (
+        cef_response_t* self,
+        cef_string_multimap_t headerMap) nothrow set_header_map;
+
+    ///
+    // Get the resolved URL after redirects or changed as a result of HSTS.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_response_t* self) nothrow get_url;
+
+    ///
+    // Set the resolved URL after redirects or changed as a result of HSTS.
+    ///
+    extern(System) void function (cef_response_t* self, const(cef_string_t)* url) nothrow set_url;
+}
+
+
+
+///
+// Create a new cef_response_t object.
+///
+cef_response_t* cef_response_create ();
+
+// CEF_INCLUDE_CAPI_CEF_RESPONSE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=cdadf516dc77455c5a3d6633bfb12e1cb276b9bb$
+//
+
+extern (C):
+
+///
+// Implement this structure to filter resource response content. The functions
+// of this structure will be called on the browser process IO thread.
+///
+struct cef_response_filter_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Initialize the response filter. Will only be called a single time. The
+    // filter will not be installed if this function returns false (0).
+    ///
+    extern(System) int function (cef_response_filter_t* self) nothrow init_filter;
+
+    ///
+    // Called to filter a chunk of data. Expected usage is as follows:
+    //
+    //  A. Read input data from |data_in| and set |data_in_read| to the number of
+    //     bytes that were read up to a maximum of |data_in_size|. |data_in| will
+    //     be NULL if |data_in_size| is zero.
+    //  B. Write filtered output data to |data_out| and set |data_out_written| to
+    //     the number of bytes that were written up to a maximum of
+    //     |data_out_size|. If no output data was written then all data must be
+    //     read from |data_in| (user must set |data_in_read| = |data_in_size|).
+    //  C. Return RESPONSE_FILTER_DONE if all output data was written or
+    //     RESPONSE_FILTER_NEED_MORE_DATA if output data is still pending.
+    //
+    // This function will be called repeatedly until the input buffer has been
+    // fully read (user sets |data_in_read| = |data_in_size|) and there is no more
+    // input data to filter (the resource response is complete). This function may
+    // then be called an additional time with an NULL input buffer if the user
+    // filled the output buffer (set |data_out_written| = |data_out_size|) and
+    // returned RESPONSE_FILTER_NEED_MORE_DATA to indicate that output data is
+    // still pending.
+    //
+    // Calls to this function will stop when one of the following conditions is
+    // met:
+    //
+    //  A. There is no more input data to filter (the resource response is
+    //     complete) and the user sets |data_out_written| = 0 or returns
+    //     RESPONSE_FILTER_DONE to indicate that all data has been written, or;
+    //  B. The user returns RESPONSE_FILTER_ERROR to indicate an error.
+    //
+    // Do not keep a reference to the buffers passed to this function.
+    ///
+    extern(System) cef_response_filter_status_t function (
+        cef_response_filter_t* self,
+        void* data_in,
+        size_t data_in_size,
+        size_t* data_in_read,
+        void* data_out,
+        size_t data_out_size,
+        size_t* data_out_written) nothrow filter;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_RESPONSE_FILTER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=9384e0b2bc27ccbdd7ebb1a86f213c28fd2784a1$
+//
+
+extern (C):
+
+///
+// Structure that manages custom scheme registrations.
+///
+struct cef_scheme_registrar_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_scoped_t base;
+
+    ///
+    // Register a custom scheme. This function should not be called for the built-
+    // in HTTP, HTTPS, FILE, FTP, ABOUT and DATA schemes.
+    //
+    // See cef_scheme_options_t for possible values for |options|.
+    //
+    // This function may be called on any thread. It should only be called once
+    // per unique |scheme_name| value. If |scheme_name| is already registered or
+    // if an error occurs this function will return false (0).
+    ///
+    extern(System) int function (
+        cef_scheme_registrar_t* self,
+        const(cef_string_t)* scheme_name,
+        int options) nothrow add_custom_scheme;
+}
+
+
+
+///
+// Structure that creates cef_resource_handler_t instances for handling scheme
+// requests. The functions of this structure will always be called on the IO
+// thread.
+///
+struct cef_scheme_handler_factory_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Return a new resource handler instance to handle the request or an NULL
+    // reference to allow default handling of the request. |browser| and |frame|
+    // will be the browser window and frame respectively that originated the
+    // request or NULL if the request did not originate from a browser window (for
+    // example, if the request came from cef_urlrequest_t). The |request| object
+    // passed to this function cannot be modified.
+    ///
+    extern(System) cef_resource_handler_t* function (
+        cef_scheme_handler_factory_t* self,
+        cef_browser_t* browser,
+        cef_frame_t* frame,
+        const(cef_string_t)* scheme_name,
+        cef_request_t* request) nothrow create;
+}
+
+
+
+///
+// Register a scheme handler factory with the global request context. An NULL
+// |domain_name| value for a standard scheme will cause the factory to match all
+// domain names. The |domain_name| value will be ignored for non-standard
+// schemes. If |scheme_name| is a built-in scheme and no handler is returned by
+// |factory| then the built-in scheme handler factory will be called. If
+// |scheme_name| is a custom scheme then you must also implement the
+// cef_app_t::on_register_custom_schemes() function in all processes. This
+// function may be called multiple times to change or remove the factory that
+// matches the specified |scheme_name| and optional |domain_name|. Returns false
+// (0) if an error occurs. This function may be called on any thread in the
+// browser process. Using this function is equivalent to calling cef_request_con
+// text_t::cef_request_context_get_global_context()->register_scheme_handler_fac
+// tory().
+///
+int cef_register_scheme_handler_factory (
+    const(cef_string_t)* scheme_name,
+    const(cef_string_t)* domain_name,
+    cef_scheme_handler_factory_t* factory);
+
+///
+// Clear all scheme handler factories registered with the global request
+// context. Returns false (0) on error. This function may be called on any
+// thread in the browser process. Using this function is equivalent to calling c
+// ef_request_context_t::cef_request_context_get_global_context()->clear_scheme_
+// handler_factories().
+///
+int cef_clear_scheme_handler_factories ();
+
+// CEF_INCLUDE_CAPI_CEF_SCHEME_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=37b3332057dbcf705b61a51cf14640d171d18a74$
+//
+
+extern (C):
+
+///
+// Structure representing a server that supports HTTP and WebSocket requests.
+// Server capacity is limited and is intended to handle only a small number of
+// simultaneous connections (e.g. for communicating between applications on
+// localhost). The functions of this structure are safe to call from any thread
+// in the brower process unless otherwise indicated.
+///
+struct cef_server_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the task runner for the dedicated server thread.
+    ///
+    extern(System) cef_task_runner_t* function (cef_server_t* self) nothrow get_task_runner;
+
+    ///
+    // Stop the server and shut down the dedicated server thread. See
+    // cef_server_handler_t::OnServerCreated documentation for a description of
+    // server lifespan.
+    ///
+    extern(System) void function (cef_server_t* self) nothrow shutdown;
+
+    ///
+    // Returns true (1) if the server is currently running and accepting incoming
+    // connections. See cef_server_handler_t::OnServerCreated documentation for a
+    // description of server lifespan. This function must be called on the
+    // dedicated server thread.
+    ///
+    extern(System) int function (cef_server_t* self) nothrow is_running;
+
+    ///
+    // Returns the server address including the port number.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_server_t* self) nothrow get_address;
+
+    ///
+    // Returns true (1) if the server currently has a connection. This function
+    // must be called on the dedicated server thread.
+    ///
+    extern(System) int function (cef_server_t* self) nothrow has_connection;
+
+    ///
+    // Returns true (1) if |connection_id| represents a valid connection. This
+    // function must be called on the dedicated server thread.
+    ///
+    extern(System) int function (cef_server_t* self, int connection_id) nothrow is_valid_connection;
+
+    ///
+    // Send an HTTP 200 "OK" response to the connection identified by
+    // |connection_id|. |content_type| is the response content type (e.g.
+    // "text/html"), |data| is the response content, and |data_size| is the size
+    // of |data| in bytes. The contents of |data| will be copied. The connection
+    // will be closed automatically after the response is sent.
+    ///
+    extern(System) void function (
+        cef_server_t* self,
+        int connection_id,
+        const(cef_string_t)* content_type,
+        const(void)* data,
+        size_t data_size) nothrow send_http200response;
+
+    ///
+    // Send an HTTP 404 "Not Found" response to the connection identified by
+    // |connection_id|. The connection will be closed automatically after the
+    // response is sent.
+    ///
+    extern(System) void function (
+        cef_server_t* self,
+        int connection_id) nothrow send_http404response;
+
+    ///
+    // Send an HTTP 500 "Internal Server Error" response to the connection
+    // identified by |connection_id|. |error_message| is the associated error
+    // message. The connection will be closed automatically after the response is
+    // sent.
+    ///
+    extern(System) void function (
+        cef_server_t* self,
+        int connection_id,
+        const(cef_string_t)* error_message) nothrow send_http500response;
+
+    ///
+    // Send a custom HTTP response to the connection identified by
+    // |connection_id|. |response_code| is the HTTP response code sent in the
+    // status line (e.g. 200), |content_type| is the response content type sent as
+    // the "Content-Type" header (e.g. "text/html"), |content_length| is the
+    // expected content length, and |extra_headers| is the map of extra response
+    // headers. If |content_length| is >= 0 then the "Content-Length" header will
+    // be sent. If |content_length| is 0 then no content is expected and the
+    // connection will be closed automatically after the response is sent. If
+    // |content_length| is < 0 then no "Content-Length" header will be sent and
+    // the client will continue reading until the connection is closed. Use the
+    // SendRawData function to send the content, if applicable, and call
+    // CloseConnection after all content has been sent.
+    ///
+    extern(System) void function (
+        cef_server_t* self,
+        int connection_id,
+        int response_code,
+        const(cef_string_t)* content_type,
+        int64 content_length,
+        cef_string_multimap_t extra_headers) nothrow send_http_response;
+
+    ///
+    // Send raw data directly to the connection identified by |connection_id|.
+    // |data| is the raw data and |data_size| is the size of |data| in bytes. The
+    // contents of |data| will be copied. No validation of |data| is performed
+    // internally so the client should be careful to send the amount indicated by
+    // the "Content-Length" header, if specified. See SendHttpResponse
+    // documentation for intended usage.
+    ///
+    extern(System) void function (
+        cef_server_t* self,
+        int connection_id,
+        const(void)* data,
+        size_t data_size) nothrow send_raw_data;
+
+    ///
+    // Close the connection identified by |connection_id|. See SendHttpResponse
+    // documentation for intended usage.
+    ///
+    extern(System) void function (cef_server_t* self, int connection_id) nothrow close_connection;
+
+    ///
+    // Send a WebSocket message to the connection identified by |connection_id|.
+    // |data| is the response content and |data_size| is the size of |data| in
+    // bytes. The contents of |data| will be copied. See
+    // cef_server_handler_t::OnWebSocketRequest documentation for intended usage.
+    ///
+    extern(System) void function (
+        cef_server_t* self,
+        int connection_id,
+        const(void)* data,
+        size_t data_size) nothrow send_web_socket_message;
+}
+
+
+
+///
+// Create a new server that binds to |address| and |port|. |address| must be a
+// valid IPv4 or IPv6 address (e.g. 127.0.0.1 or ::1) and |port| must be a port
+// number outside of the reserved range (e.g. between 1025 and 65535 on most
+// platforms). |backlog| is the maximum number of pending connections. A new
+// thread will be created for each CreateServer call (the "dedicated server
+// thread"). It is therefore recommended to use a different cef_server_handler_t
+// instance for each CreateServer call to avoid thread safety issues in the
+// cef_server_handler_t implementation. The
+// cef_server_handler_t::OnServerCreated function will be called on the
+// dedicated server thread to report success or failure. See
+// cef_server_handler_t::OnServerCreated documentation for a description of
+// server lifespan.
+///
+void cef_server_create (
+    const(cef_string_t)* address,
+    uint16 port,
+    int backlog,
+    cef_server_handler_t* handler);
+
+///
+// Implement this structure to handle HTTP server requests. A new thread will be
+// created for each cef_server_t::CreateServer call (the "dedicated server
+// thread"), and the functions of this structure will be called on that thread.
+// It is therefore recommended to use a different cef_server_handler_t instance
+// for each cef_server_t::CreateServer call to avoid thread safety issues in the
+// cef_server_handler_t implementation.
+///
+struct cef_server_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called when |server| is created. If the server was started successfully
+    // then cef_server_t::IsRunning will return true (1). The server will continue
+    // running until cef_server_t::Shutdown is called, after which time
+    // OnServerDestroyed will be called. If the server failed to start then
+    // OnServerDestroyed will be called immediately after this function returns.
+    ///
+    extern(System) void function (
+        cef_server_handler_t* self,
+        cef_server_t* server) nothrow on_server_created;
+
+    ///
+    // Called when |server| is destroyed. The server thread will be stopped after
+    // this function returns. The client should release any references to |server|
+    // when this function is called. See OnServerCreated documentation for a
+    // description of server lifespan.
+    ///
+    extern(System) void function (
+        cef_server_handler_t* self,
+        cef_server_t* server) nothrow on_server_destroyed;
+
+    ///
+    // Called when a client connects to |server|. |connection_id| uniquely
+    // identifies the connection. Each call to this function will have a matching
+    // call to OnClientDisconnected.
+    ///
+    extern(System) void function (
+        cef_server_handler_t* self,
+        cef_server_t* server,
+        int connection_id) nothrow on_client_connected;
+
+    ///
+    // Called when a client disconnects from |server|. |connection_id| uniquely
+    // identifies the connection. The client should release any data associated
+    // with |connection_id| when this function is called and |connection_id|
+    // should no longer be passed to cef_server_t functions. Disconnects can
+    // originate from either the client or the server. For example, the server
+    // will disconnect automatically after a cef_server_t::SendHttpXXXResponse
+    // function is called.
+    ///
+    extern(System) void function (
+        cef_server_handler_t* self,
+        cef_server_t* server,
+        int connection_id) nothrow on_client_disconnected;
+
+    ///
+    // Called when |server| receives an HTTP request. |connection_id| uniquely
+    // identifies the connection, |client_address| is the requesting IPv4 or IPv6
+    // client address including port number, and |request| contains the request
+    // contents (URL, function, headers and optional POST data). Call cef_server_t
+    // functions either synchronously or asynchronusly to send a response.
+    ///
+    extern(System) void function (
+        cef_server_handler_t* self,
+        cef_server_t* server,
+        int connection_id,
+        const(cef_string_t)* client_address,
+        cef_request_t* request) nothrow on_http_request;
+
+    ///
+    // Called when |server| receives a WebSocket request. |connection_id| uniquely
+    // identifies the connection, |client_address| is the requesting IPv4 or IPv6
+    // client address including port number, and |request| contains the request
+    // contents (URL, function, headers and optional POST data). Execute
+    // |callback| either synchronously or asynchronously to accept or decline the
+    // WebSocket connection. If the request is accepted then OnWebSocketConnected
+    // will be called after the WebSocket has connected and incoming messages will
+    // be delivered to the OnWebSocketMessage callback. If the request is declined
+    // then the client will be disconnected and OnClientDisconnected will be
+    // called. Call the cef_server_t::SendWebSocketMessage function after
+    // receiving the OnWebSocketConnected callback to respond with WebSocket
+    // messages.
+    ///
+    extern(System) void function (
+        cef_server_handler_t* self,
+        cef_server_t* server,
+        int connection_id,
+        const(cef_string_t)* client_address,
+        cef_request_t* request,
+        cef_callback_t* callback) nothrow on_web_socket_request;
+
+    ///
+    // Called after the client has accepted the WebSocket connection for |server|
+    // and |connection_id| via the OnWebSocketRequest callback. See
+    // OnWebSocketRequest documentation for intended usage.
+    ///
+    extern(System) void function (
+        cef_server_handler_t* self,
+        cef_server_t* server,
+        int connection_id) nothrow on_web_socket_connected;
+
+    ///
+    // Called when |server| receives an WebSocket message. |connection_id|
+    // uniquely identifies the connection, |data| is the message content and
+    // |data_size| is the size of |data| in bytes. Do not keep a reference to
+    // |data| outside of this function. See OnWebSocketRequest documentation for
+    // intended usage.
+    ///
+    extern(System) void function (
+        cef_server_handler_t* self,
+        cef_server_t* server,
+        int connection_id,
+        const(void)* data,
+        size_t data_size) nothrow on_web_socket_message;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_SERVER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=aefb3b63aba8f5df6ab6dc11e2029820c75c36cf$
+//
+
+extern (C):
+
+///
+// Structure representing SSL information.
+///
+struct cef_sslinfo_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns a bitmask containing any and all problems verifying the server
+    // certificate.
+    ///
+    extern(System) cef_cert_status_t function (cef_sslinfo_t* self) nothrow get_cert_status;
+
+    ///
+    // Returns the X.509 certificate.
+    ///
+    extern(System) cef_x509certificate_t* function (
+        cef_sslinfo_t* self) nothrow get_x509certificate;
+}
+
+
+
+///
+// Returns true (1) if the certificate status represents an error.
+///
+int cef_is_cert_status_error (cef_cert_status_t status);
+
+// CEF_INCLUDE_CAPI_CEF_SSL_INFO_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=93eb2bc0f51da08a41fb906436654b3452b74fb3$
+//
+
+extern (C):
+
+///
+// Structure representing the SSL information for a navigation entry.
+///
+struct cef_sslstatus_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if the status is related to a secure SSL/TLS connection.
+    ///
+    extern(System) int function (cef_sslstatus_t* self) nothrow is_secure_connection;
+
+    ///
+    // Returns a bitmask containing any and all problems verifying the server
+    // certificate.
+    ///
+    extern(System) cef_cert_status_t function (cef_sslstatus_t* self) nothrow get_cert_status;
+
+    ///
+    // Returns the SSL version used for the SSL connection.
+    ///
+    extern(System) cef_ssl_version_t function (cef_sslstatus_t* self) nothrow get_sslversion;
+
+    ///
+    // Returns a bitmask containing the page security content status.
+    ///
+    extern(System) cef_ssl_content_status_t function (
+        cef_sslstatus_t* self) nothrow get_content_status;
+
+    ///
+    // Returns the X.509 certificate.
+    ///
+    extern(System) cef_x509certificate_t* function (
+        cef_sslstatus_t* self) nothrow get_x509certificate;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_SSL_STATUS_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=61ff7a4ebc917482bad5daba7089b92cc62bada8$
+//
+
+extern (C):
+
+///
+// Structure the client can implement to provide a custom stream reader. The
+// functions of this structure may be called on any thread.
+///
+struct cef_read_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Read raw binary data.
+    ///
+    extern(System) size_t function (
+        cef_read_handler_t* self,
+        void* ptr,
+        size_t size,
+        size_t n) nothrow read;
+
+    ///
+    // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+    // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
+    ///
+    extern(System) int function (cef_read_handler_t* self, int64 offset, int whence) nothrow seek;
+
+    ///
+    // Return the current offset position.
+    ///
+    extern(System) int64 function (cef_read_handler_t* self) nothrow tell;
+
+    ///
+    // Return non-zero if at end of file.
+    ///
+    extern(System) int function (cef_read_handler_t* self) nothrow eof;
+
+    ///
+    // Return true (1) if this handler performs work like accessing the file
+    // system which may block. Used as a hint for determining the thread to access
+    // the handler from.
+    ///
+    extern(System) int function (cef_read_handler_t* self) nothrow may_block;
+}
+
+
+
+///
+// Structure used to read data from a stream. The functions of this structure
+// may be called on any thread.
+///
+struct cef_stream_reader_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Read raw binary data.
+    ///
+    extern(System) size_t function (
+        cef_stream_reader_t* self,
+        void* ptr,
+        size_t size,
+        size_t n) nothrow read;
+
+    ///
+    // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+    // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
+    ///
+    extern(System) int function (cef_stream_reader_t* self, int64 offset, int whence) nothrow seek;
+
+    ///
+    // Return the current offset position.
+    ///
+    extern(System) int64 function (cef_stream_reader_t* self) nothrow tell;
+
+    ///
+    // Return non-zero if at end of file.
+    ///
+    extern(System) int function (cef_stream_reader_t* self) nothrow eof;
+
+    ///
+    // Returns true (1) if this reader performs work like accessing the file
+    // system which may block. Used as a hint for determining the thread to access
+    // the reader from.
+    ///
+    extern(System) int function (cef_stream_reader_t* self) nothrow may_block;
+}
+
+
+
+///
+// Create a new cef_stream_reader_t object from a file.
+///
+cef_stream_reader_t* cef_stream_reader_create_for_file (
+    const(cef_string_t)* fileName);
+
+///
+// Create a new cef_stream_reader_t object from data.
+///
+cef_stream_reader_t* cef_stream_reader_create_for_data (
+    void* data,
+    size_t size);
+
+///
+// Create a new cef_stream_reader_t object from a custom handler.
+///
+cef_stream_reader_t* cef_stream_reader_create_for_handler (
+    cef_read_handler_t* handler);
+
+///
+// Structure the client can implement to provide a custom stream writer. The
+// functions of this structure may be called on any thread.
+///
+struct cef_write_handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Write raw binary data.
+    ///
+    extern(System) size_t function (
+        cef_write_handler_t* self,
+        const(void)* ptr,
+        size_t size,
+        size_t n) nothrow write;
+
+    ///
+    // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+    // SEEK_END or SEEK_SET. Return zero on success and non-zero on failure.
+    ///
+    extern(System) int function (cef_write_handler_t* self, int64 offset, int whence) nothrow seek;
+
+    ///
+    // Return the current offset position.
+    ///
+    extern(System) int64 function (cef_write_handler_t* self) nothrow tell;
+
+    ///
+    // Flush the stream.
+    ///
+    extern(System) int function (cef_write_handler_t* self) nothrow flush;
+
+    ///
+    // Return true (1) if this handler performs work like accessing the file
+    // system which may block. Used as a hint for determining the thread to access
+    // the handler from.
+    ///
+    extern(System) int function (cef_write_handler_t* self) nothrow may_block;
+}
+
+
+
+///
+// Structure used to write data to a stream. The functions of this structure may
+// be called on any thread.
+///
+struct cef_stream_writer_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Write raw binary data.
+    ///
+    extern(System) size_t function (
+        cef_stream_writer_t* self,
+        const(void)* ptr,
+        size_t size,
+        size_t n) nothrow write;
+
+    ///
+    // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
+    // SEEK_END or SEEK_SET. Returns zero on success and non-zero on failure.
+    ///
+    extern(System) int function (cef_stream_writer_t* self, int64 offset, int whence) nothrow seek;
+
+    ///
+    // Return the current offset position.
+    ///
+    extern(System) int64 function (cef_stream_writer_t* self) nothrow tell;
+
+    ///
+    // Flush the stream.
+    ///
+    extern(System) int function (cef_stream_writer_t* self) nothrow flush;
+
+    ///
+    // Returns true (1) if this writer performs work like accessing the file
+    // system which may block. Used as a hint for determining the thread to access
+    // the writer from.
+    ///
+    extern(System) int function (cef_stream_writer_t* self) nothrow may_block;
+}
+
+
+
+///
+// Create a new cef_stream_writer_t object for a file.
+///
+cef_stream_writer_t* cef_stream_writer_create_for_file (
+    const(cef_string_t)* fileName);
+
+///
+// Create a new cef_stream_writer_t object for a custom handler.
+///
+cef_stream_writer_t* cef_stream_writer_create_for_handler (
+    cef_write_handler_t* handler);
+
+// CEF_INCLUDE_CAPI_CEF_STREAM_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=30d4a63d53bce310ad641cbe5096ae126a664076$
+//
+
+extern (C):
+
+///
+// Implement this structure to receive string values asynchronously.
+///
+struct cef_string_visitor_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be executed.
+    ///
+    extern(System) void function (
+        cef_string_visitor_t* self,
+        const(cef_string_t)* string) nothrow visit;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_STRING_VISITOR_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=a8b2162b7c3b7cede392e8531c46a1277e990689$
+//
+
+extern (C):
+
+///
+// Implement this structure for asynchronous task execution. If the task is
+// posted successfully and if the associated message loop is still running then
+// the execute() function will be called on the target thread. If the task fails
+// to post then the task object may be destroyed on the source thread instead of
+// the target thread. For this reason be cautious when performing work in the
+// task object destructor.
+///
+struct cef_task_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be executed on the target thread.
+    ///
+    extern(System) void function (cef_task_t* self) nothrow execute;
+}
+
+
+
+///
+// Structure that asynchronously executes tasks on the associated thread. It is
+// safe to call the functions of this structure on any thread.
+//
+// CEF maintains multiple internal threads that are used for handling different
+// types of tasks in different processes. The cef_thread_id_t definitions in
+// cef_types.h list the common CEF threads. Task runners are also available for
+// other CEF threads as appropriate (for example, V8 WebWorker threads).
+///
+struct cef_task_runner_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is pointing to the same task runner as
+    // |that| object.
+    ///
+    extern(System) int function (cef_task_runner_t* self, cef_task_runner_t* that) nothrow is_same;
+
+    ///
+    // Returns true (1) if this task runner belongs to the current thread.
+    ///
+    extern(System) int function (cef_task_runner_t* self) nothrow belongs_to_current_thread;
+
+    ///
+    // Returns true (1) if this task runner is for the specified CEF thread.
+    ///
+    extern(System) int function (
+        cef_task_runner_t* self,
+        cef_thread_id_t threadId) nothrow belongs_to_thread;
+
+    ///
+    // Post a task for execution on the thread associated with this task runner.
+    // Execution will occur asynchronously.
+    ///
+    extern(System) int function (cef_task_runner_t* self, cef_task_t* task) nothrow post_task;
+
+    ///
+    // Post a task for delayed execution on the thread associated with this task
+    // runner. Execution will occur asynchronously. Delayed tasks are not
+    // supported on V8 WebWorker threads and will be executed without the
+    // specified delay.
+    ///
+    extern(System) int function (
+        cef_task_runner_t* self,
+        cef_task_t* task,
+        int64 delay_ms) nothrow post_delayed_task;
+}
+
+
+
+///
+// Returns the task runner for the current thread. Only CEF threads will have
+// task runners. An NULL reference will be returned if this function is called
+// on an invalid thread.
+///
+cef_task_runner_t* cef_task_runner_get_for_current_thread ();
+
+///
+// Returns the task runner for the specified CEF thread.
+///
+cef_task_runner_t* cef_task_runner_get_for_thread (cef_thread_id_t threadId);
+
+///
+// Returns true (1) if called on the specified thread. Equivalent to using
+// cef_task_runner_t::GetForThread(threadId)->belongs_to_current_thread().
+///
+int cef_currently_on (cef_thread_id_t threadId);
+
+///
+// Post a task for execution on the specified thread. Equivalent to using
+// cef_task_runner_t::GetForThread(threadId)->PostTask(task).
+///
+int cef_post_task (cef_thread_id_t threadId, cef_task_t* task);
+
+///
+// Post a task for delayed execution on the specified thread. Equivalent to
+// using cef_task_runner_t::GetForThread(threadId)->PostDelayedTask(task,
+// delay_ms).
+///
+int cef_post_delayed_task (
+    cef_thread_id_t threadId,
+    cef_task_t* task,
+    int64 delay_ms);
+
+// CEF_INCLUDE_CAPI_CEF_TASK_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=9a471c97e43ad3d1d042ba3dc6d887f2f4b0d851$
+//
+
+extern (C):
+
+///
+// A simple thread abstraction that establishes a message loop on a new thread.
+// The consumer uses cef_task_runner_t to execute code on the thread's message
+// loop. The thread is terminated when the cef_thread_t object is destroyed or
+// stop() is called. All pending tasks queued on the thread's message loop will
+// run to completion before the thread is terminated. cef_thread_create() can be
+// called on any valid CEF thread in either the browser or render process. This
+// structure should only be used for tasks that require a dedicated thread. In
+// most cases you can post tasks to an existing CEF thread instead of creating a
+// new one; see cef_task.h for details.
+///
+struct cef_thread_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the cef_task_runner_t that will execute code on this thread's
+    // message loop. This function is safe to call from any thread.
+    ///
+    extern(System) cef_task_runner_t* function (cef_thread_t* self) nothrow get_task_runner;
+
+    ///
+    // Returns the platform thread ID. It will return the same value after stop()
+    // is called. This function is safe to call from any thread.
+    ///
+    extern(System) cef_platform_thread_id_t function (
+        cef_thread_t* self) nothrow get_platform_thread_id;
+
+    ///
+    // Stop and join the thread. This function must be called from the same thread
+    // that called cef_thread_create(). Do not call this function if
+    // cef_thread_create() was called with a |stoppable| value of false (0).
+    ///
+    extern(System) void function (cef_thread_t* self) nothrow stop;
+
+    ///
+    // Returns true (1) if the thread is currently running. This function must be
+    // called from the same thread that called cef_thread_create().
+    ///
+    extern(System) int function (cef_thread_t* self) nothrow is_running;
+}
+
+
+
+///
+// Create and start a new thread. This function does not block waiting for the
+// thread to run initialization. |display_name| is the name that will be used to
+// identify the thread. |priority| is the thread execution priority.
+// |message_loop_type| indicates the set of asynchronous events that the thread
+// can process. If |stoppable| is true (1) the thread will stopped and joined on
+// destruction or when stop() is called; otherwise, the thread cannot be stopped
+// and will be leaked on shutdown. On Windows the |com_init_mode| value
+// specifies how COM will be initialized for the thread. If |com_init_mode| is
+// set to COM_INIT_MODE_STA then |message_loop_type| must be set to ML_TYPE_UI.
+///
+cef_thread_t* cef_thread_create (
+    const(cef_string_t)* display_name,
+    cef_thread_priority_t priority,
+    cef_message_loop_type_t message_loop_type,
+    int stoppable,
+    cef_com_init_mode_t com_init_mode);
+
+// CEF_INCLUDE_CAPI_CEF_THREAD_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=99779f8a728d2e1a0b87d6d6b89bd28e5da16d4c$
+//
+
+extern (C):
+
+///
+// Implement this structure to receive notification when tracing has completed.
+// The functions of this structure will be called on the browser process UI
+// thread.
+///
+struct cef_end_tracing_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Called after all processes have sent their trace data. |tracing_file| is
+    // the path at which tracing data was written. The client is responsible for
+    // deleting |tracing_file|.
+    ///
+    extern(System) void function (
+        cef_end_tracing_callback_t* self,
+        const(cef_string_t)* tracing_file) nothrow on_end_tracing_complete;
+}
+
+
+
+///
+// Start tracing events on all processes. Tracing is initialized asynchronously
+// and |callback| will be executed on the UI thread after initialization is
+// complete.
+//
+// If CefBeginTracing was called previously, or if a CefEndTracingAsync call is
+// pending, CefBeginTracing will fail and return false (0).
+//
+// |categories| is a comma-delimited list of category wildcards. A category can
+// have an optional '-' prefix to make it an excluded category. Having both
+// included and excluded categories in the same list is not supported.
+//
+// Example: "test_MyTest*" Example: "test_MyTest*,test_OtherStuff" Example:
+// "-excluded_category1,-excluded_category2"
+//
+// This function must be called on the browser process UI thread.
+///
+int cef_begin_tracing (
+    const(cef_string_t)* categories,
+    cef_completion_callback_t* callback);
+
+///
+// Stop tracing events on all processes.
+//
+// This function will fail and return false (0) if a previous call to
+// CefEndTracingAsync is already pending or if CefBeginTracing was not called.
+//
+// |tracing_file| is the path at which tracing data will be written and
+// |callback| is the callback that will be executed once all processes have sent
+// their trace data. If |tracing_file| is NULL a new temporary file path will be
+// used. If |callback| is NULL no trace data will be written.
+//
+// This function must be called on the browser process UI thread.
+///
+int cef_end_tracing (
+    const(cef_string_t)* tracing_file,
+    cef_end_tracing_callback_t* callback);
+
+///
+// Returns the current system trace time or, if none is defined, the current
+// high-res time. Can be used by clients to synchronize with the time
+// information in trace events.
+///
+int64 cef_now_from_system_trace_time ();
+
+// CEF_INCLUDE_CAPI_CEF_TRACE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=11c227079ec0687adeaa8a085aeec37c89346ee7$
+//
+
+extern (C):
+
+///
+// Structure used to make a URL request. URL requests are not associated with a
+// browser instance so no cef_client_t callbacks will be executed. URL requests
+// can be created on any valid CEF thread in either the browser or render
+// process. Once created the functions of the URL request object must be
+// accessed on the same thread that created it.
+///
+struct cef_urlrequest_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the request object used to create this URL request. The returned
+    // object is read-only and should not be modified.
+    ///
+    extern(System) cef_request_t* function (cef_urlrequest_t* self) nothrow get_request;
+
+    ///
+    // Returns the client.
+    ///
+    extern(System) cef_urlrequest_client_t* function (cef_urlrequest_t* self) nothrow get_client;
+
+    ///
+    // Returns the request status.
+    ///
+    extern(System) cef_urlrequest_status_t function (
+        cef_urlrequest_t* self) nothrow get_request_status;
+
+    ///
+    // Returns the request error if status is UR_CANCELED or UR_FAILED, or 0
+    // otherwise.
+    ///
+    extern(System) cef_errorcode_t function (cef_urlrequest_t* self) nothrow get_request_error;
+
+    ///
+    // Returns the response, or NULL if no response information is available.
+    // Response information will only be available after the upload has completed.
+    // The returned object is read-only and should not be modified.
+    ///
+    extern(System) cef_response_t* function (cef_urlrequest_t* self) nothrow get_response;
+
+    ///
+    // Returns true (1) if the response body was served from the cache. This
+    // includes responses for which revalidation was required.
+    ///
+    extern(System) int function (cef_urlrequest_t* self) nothrow response_was_cached;
 
     ///
     // Cancel the request.
     ///
-    void function (_cef_get_extension_resource_callback_t* self) nothrow cancel;
+    extern(System) void function (cef_urlrequest_t* self) nothrow cancel;
 }
 
-alias cef_get_extension_resource_callback_t = _cef_get_extension_resource_callback_t;
+
 
 ///
-// Implement this structure to handle events related to browser extensions. The
-// functions of this structure will be called on the UI thread. See
-// cef_request_context_t::LoadExtension for information about extension loading.
+// Create a new URL request that is not associated with a specific browser or
+// frame. Use cef_frame_t::CreateURLRequest instead if you want the request to
+// have this association, in which case it may be handled differently (see
+// documentation on that function). A request created with this function may
+// only originate from the browser process, and will behave as follows:
+//   - It may be intercepted by the client via CefResourceRequestHandler or
+//     CefSchemeHandlerFactory.
+//   - POST data may only contain only a single element of type PDE_TYPE_FILE
+//     or PDE_TYPE_BYTES.
+//   - If |request_context| is empty the global request context will be used.
+//
+// The |request| object will be marked as read-only after calling this function.
 ///
-struct _cef_extension_handler_t
+cef_urlrequest_t* cef_urlrequest_create (
+    cef_request_t* request,
+    cef_urlrequest_client_t* client,
+    cef_request_context_t* request_context);
+
+///
+// Structure that should be implemented by the cef_urlrequest_t client. The
+// functions of this structure will be called on the same thread that created
+// the request unless otherwise documented.
+///
+struct cef_urlrequest_client_t
 {
     ///
     // Base structure.
@@ -18672,263 +16770,2718 @@ struct _cef_extension_handler_t
     cef_base_ref_counted_t base;
 
     ///
-    // Called if the cef_request_context_t::LoadExtension request fails. |result|
-    // will be the error code.
+    // Notifies the client that the request has completed. Use the
+    // cef_urlrequest_t::GetRequestStatus function to determine if the request was
+    // successful or not.
     ///
-    void function (
-        _cef_extension_handler_t* self,
-        cef_errorcode_t result) nothrow on_extension_load_failed;
+    extern(System) void function (
+        cef_urlrequest_client_t* self,
+        cef_urlrequest_t* request) nothrow on_request_complete;
 
     ///
-    // Called if the cef_request_context_t::LoadExtension request succeeds.
-    // |extension| is the loaded extension.
+    // Notifies the client of upload progress. |current| denotes the number of
+    // bytes sent so far and |total| is the total size of uploading data (or -1 if
+    // chunked upload is enabled). This function will only be called if the
+    // UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.
     ///
-    void function (
-        _cef_extension_handler_t* self,
-        _cef_extension_t* extension) nothrow on_extension_loaded;
+    extern(System) void function (
+        cef_urlrequest_client_t* self,
+        cef_urlrequest_t* request,
+        int64 current,
+        int64 total) nothrow on_upload_progress;
 
     ///
-    // Called after the cef_extension_t::Unload request has completed.
+    // Notifies the client of download progress. |current| denotes the number of
+    // bytes received up to the call and |total| is the expected total size of the
+    // response (or -1 if not determined).
     ///
-    void function (
-        _cef_extension_handler_t* self,
-        _cef_extension_t* extension) nothrow on_extension_unloaded;
+    extern(System) void function (
+        cef_urlrequest_client_t* self,
+        cef_urlrequest_t* request,
+        int64 current,
+        int64 total) nothrow on_download_progress;
 
     ///
-    // Called when an extension needs a browser to host a background script
-    // specified via the "background" manifest key. The browser will have no
-    // visible window and cannot be displayed. |extension| is the extension that
-    // is loading the background script. |url| is an internally generated
-    // reference to an HTML page that will be used to load the background script
-    // via a <script> src attribute. To allow creation of the browser optionally
-    // modify |client| and |settings| and return false (0). To cancel creation of
-    // the browser (and consequently cancel load of the background script) return
-    // true (1). Successful creation will be indicated by a call to
-    // cef_life_span_handler_t::OnAfterCreated, and
-    // cef_browser_host_t::IsBackgroundHost will return true (1) for the resulting
-    // browser. See https://developer.chrome.com/extensions/event_pages for more
-    // information about extension background script usage.
+    // Called when some part of the response is read. |data| contains the current
+    // bytes received since the last call. This function will not be called if the
+    // UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request.
     ///
-    int function (
-        _cef_extension_handler_t* self,
-        _cef_extension_t* extension,
-        const(cef_string_t)* url,
-        _cef_client_t** client,
-        _cef_browser_settings_t* settings) nothrow on_before_background_browser;
+    extern(System) void function (
+        cef_urlrequest_client_t* self,
+        cef_urlrequest_t* request,
+        const(void)* data,
+        size_t data_length) nothrow on_download_data;
 
     ///
-    // Called when an extension API (e.g. chrome.tabs.create) requests creation of
-    // a new browser. |extension| and |browser| are the source of the API call.
-    // |active_browser| may optionally be specified via the windowId property or
-    // returned via the get_active_browser() callback and provides the default
-    // |client| and |settings| values for the new browser. |index| is the position
-    // value optionally specified via the index property. |url| is the URL that
-    // will be loaded in the browser. |active| is true (1) if the new browser
-    // should be active when opened.  To allow creation of the browser optionally
-    // modify |windowInfo|, |client| and |settings| and return false (0). To
-    // cancel creation of the browser return true (1). Successful creation will be
-    // indicated by a call to cef_life_span_handler_t::OnAfterCreated. Any
-    // modifications to |windowInfo| will be ignored if |active_browser| is
-    // wrapped in a cef_browser_view_t.
+    // Called on the IO thread when the browser needs credentials from the user.
+    // |isProxy| indicates whether the host is a proxy server. |host| contains the
+    // hostname and |port| contains the port number. Return true (1) to continue
+    // the request and call cef_auth_callback_t::cont() when the authentication
+    // information is available. If the request has an associated browser/frame
+    // then returning false (0) will result in a call to GetAuthCredentials on the
+    // cef_request_handler_t associated with that browser, if any. Otherwise,
+    // returning false (0) will cancel the request immediately. This function will
+    // only be called for requests initiated from the browser process.
     ///
-    int function (
-        _cef_extension_handler_t* self,
-        _cef_extension_t* extension,
-        _cef_browser_t* browser,
-        _cef_browser_t* active_browser,
+    extern(System) int function (
+        cef_urlrequest_client_t* self,
+        int isProxy,
+        const(cef_string_t)* host,
+        int port,
+        const(cef_string_t)* realm,
+        const(cef_string_t)* scheme,
+        cef_auth_callback_t* callback) nothrow get_auth_credentials;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_URLREQUEST_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=23dc3ab761547687a491e5d7303b73b2d0d54e7a$
+//
+
+extern (C):
+
+///
+// Structure representing a V8 context handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the cef_v8context_t::get_task_runner() function.
+///
+struct cef_v8context_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the task runner associated with this context. V8 handles can only
+    // be accessed from the thread on which they are created. This function can be
+    // called on any render process thread.
+    ///
+    extern(System) cef_task_runner_t* function (cef_v8context_t* self) nothrow get_task_runner;
+
+    ///
+    // Returns true (1) if the underlying handle is valid and it can be accessed
+    // on the current thread. Do not call any other functions if this function
+    // returns false (0).
+    ///
+    extern(System) int function (cef_v8context_t* self) nothrow is_valid;
+
+    ///
+    // Returns the browser for this context. This function will return an NULL
+    // reference for WebWorker contexts.
+    ///
+    extern(System) cef_browser_t* function (cef_v8context_t* self) nothrow get_browser;
+
+    ///
+    // Returns the frame for this context. This function will return an NULL
+    // reference for WebWorker contexts.
+    ///
+    extern(System) cef_frame_t* function (cef_v8context_t* self) nothrow get_frame;
+
+    ///
+    // Returns the global object for this context. The context must be entered
+    // before calling this function.
+    ///
+    extern(System) cef_v8value_t* function (cef_v8context_t* self) nothrow get_global;
+
+    ///
+    // Enter this context. A context must be explicitly entered before creating a
+    // V8 Object, Array, Function or Date asynchronously. exit() must be called
+    // the same number of times as enter() before releasing this context. V8
+    // objects belong to the context in which they are created. Returns true (1)
+    // if the scope was entered successfully.
+    ///
+    extern(System) int function (cef_v8context_t* self) nothrow enter;
+
+    ///
+    // Exit this context. Call this function only after calling enter(). Returns
+    // true (1) if the scope was exited successfully.
+    ///
+    extern(System) int function (cef_v8context_t* self) nothrow exit;
+
+    ///
+    // Returns true (1) if this object is pointing to the same handle as |that|
+    // object.
+    ///
+    extern(System) int function (cef_v8context_t* self, cef_v8context_t* that) nothrow is_same;
+
+    ///
+    // Execute a string of JavaScript code in this V8 context. The |script_url|
+    // parameter is the URL where the script in question can be found, if any. The
+    // |start_line| parameter is the base line number to use for error reporting.
+    // On success |retval| will be set to the return value, if any, and the
+    // function will return true (1). On failure |exception| will be set to the
+    // exception, if any, and the function will return false (0).
+    ///
+    extern(System) int function (
+        cef_v8context_t* self,
+        const(cef_string_t)* code,
+        const(cef_string_t)* script_url,
+        int start_line,
+        cef_v8value_t** retval,
+        cef_v8exception_t** exception) nothrow eval;
+}
+
+
+
+///
+// Returns the current (top) context object in the V8 context stack.
+///
+cef_v8context_t* cef_v8context_get_current_context ();
+
+///
+// Returns the entered (bottom) context object in the V8 context stack.
+///
+cef_v8context_t* cef_v8context_get_entered_context ();
+
+///
+// Returns true (1) if V8 is currently inside a context.
+///
+int cef_v8context_in_context ();
+
+///
+// Structure that should be implemented to handle V8 function calls. The
+// functions of this structure will be called on the thread associated with the
+// V8 function.
+///
+struct cef_v8handler_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Handle execution of the function identified by |name|. |object| is the
+    // receiver ('this' object) of the function. |arguments| is the list of
+    // arguments passed to the function. If execution succeeds set |retval| to the
+    // function return value. If execution fails set |exception| to the exception
+    // that will be thrown. Return true (1) if execution was handled.
+    ///
+    extern(System) int function (
+        cef_v8handler_t* self,
+        const(cef_string_t)* name,
+        cef_v8value_t* object,
+        size_t argumentsCount,
+        cef_v8value_t** arguments,
+        cef_v8value_t** retval,
+        cef_string_t* exception) nothrow execute;
+}
+
+
+
+///
+// Structure that should be implemented to handle V8 accessor calls. Accessor
+// identifiers are registered by calling cef_v8value_t::set_value(). The
+// functions of this structure will be called on the thread associated with the
+// V8 accessor.
+///
+struct cef_v8accessor_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Handle retrieval the accessor value identified by |name|. |object| is the
+    // receiver ('this' object) of the accessor. If retrieval succeeds set
+    // |retval| to the return value. If retrieval fails set |exception| to the
+    // exception that will be thrown. Return true (1) if accessor retrieval was
+    // handled.
+    ///
+    extern(System) int function (
+        cef_v8accessor_t* self,
+        const(cef_string_t)* name,
+        cef_v8value_t* object,
+        cef_v8value_t** retval,
+        cef_string_t* exception) nothrow get;
+
+    ///
+    // Handle assignment of the accessor value identified by |name|. |object| is
+    // the receiver ('this' object) of the accessor. |value| is the new value
+    // being assigned to the accessor. If assignment fails set |exception| to the
+    // exception that will be thrown. Return true (1) if accessor assignment was
+    // handled.
+    ///
+    extern(System) int function (
+        cef_v8accessor_t* self,
+        const(cef_string_t)* name,
+        cef_v8value_t* object,
+        cef_v8value_t* value,
+        cef_string_t* exception) nothrow set;
+}
+
+
+
+///
+// Structure that should be implemented to handle V8 interceptor calls. The
+// functions of this structure will be called on the thread associated with the
+// V8 interceptor. Interceptor's named property handlers (with first argument of
+// type CefString) are called when object is indexed by string. Indexed property
+// handlers (with first argument of type int) are called when object is indexed
+// by integer.
+///
+struct cef_v8interceptor_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Handle retrieval of the interceptor value identified by |name|. |object| is
+    // the receiver ('this' object) of the interceptor. If retrieval succeeds, set
+    // |retval| to the return value. If the requested value does not exist, don't
+    // set either |retval| or |exception|. If retrieval fails, set |exception| to
+    // the exception that will be thrown. If the property has an associated
+    // accessor, it will be called only if you don't set |retval|. Return true (1)
+    // if interceptor retrieval was handled, false (0) otherwise.
+    ///
+    extern(System) int function (
+        cef_v8interceptor_t* self,
+        const(cef_string_t)* name,
+        cef_v8value_t* object,
+        cef_v8value_t** retval,
+        cef_string_t* exception) nothrow get_byname;
+
+    ///
+    // Handle retrieval of the interceptor value identified by |index|. |object|
+    // is the receiver ('this' object) of the interceptor. If retrieval succeeds,
+    // set |retval| to the return value. If the requested value does not exist,
+    // don't set either |retval| or |exception|. If retrieval fails, set
+    // |exception| to the exception that will be thrown. Return true (1) if
+    // interceptor retrieval was handled, false (0) otherwise.
+    ///
+    extern(System) int function (
+        cef_v8interceptor_t* self,
         int index,
-        const(cef_string_t)* url,
-        int active,
-        _cef_window_info_t* windowInfo,
-        _cef_client_t** client,
-        _cef_browser_settings_t* settings) nothrow on_before_browser;
+        cef_v8value_t* object,
+        cef_v8value_t** retval,
+        cef_string_t* exception) nothrow get_byindex;
 
     ///
-    // Called when no tabId is specified to an extension API call that accepts a
-    // tabId parameter (e.g. chrome.tabs.*). |extension| and |browser| are the
-    // source of the API call. Return the browser that will be acted on by the API
-    // call or return NULL to act on |browser|. The returned browser must share
-    // the same cef_request_context_t as |browser|. Incognito browsers should not
-    // be considered unless the source extension has incognito access enabled, in
-    // which case |include_incognito| will be true (1).
+    // Handle assignment of the interceptor value identified by |name|. |object|
+    // is the receiver ('this' object) of the interceptor. |value| is the new
+    // value being assigned to the interceptor. If assignment fails, set
+    // |exception| to the exception that will be thrown. This setter will always
+    // be called, even when the property has an associated accessor. Return true
+    // (1) if interceptor assignment was handled, false (0) otherwise.
     ///
-    _cef_browser_t* function (
-        _cef_extension_handler_t* self,
-        _cef_extension_t* extension,
-        _cef_browser_t* browser,
-        int include_incognito) nothrow get_active_browser;
+    extern(System) int function (
+        cef_v8interceptor_t* self,
+        const(cef_string_t)* name,
+        cef_v8value_t* object,
+        cef_v8value_t* value,
+        cef_string_t* exception) nothrow set_byname;
 
     ///
-    // Called when the tabId associated with |target_browser| is specified to an
-    // extension API call that accepts a tabId parameter (e.g. chrome.tabs.*).
-    // |extension| and |browser| are the source of the API call. Return true (1)
-    // to allow access of false (0) to deny access. Access to incognito browsers
-    // should not be allowed unless the source extension has incognito access
-    // enabled, in which case |include_incognito| will be true (1).
+    // Handle assignment of the interceptor value identified by |index|. |object|
+    // is the receiver ('this' object) of the interceptor. |value| is the new
+    // value being assigned to the interceptor. If assignment fails, set
+    // |exception| to the exception that will be thrown. Return true (1) if
+    // interceptor assignment was handled, false (0) otherwise.
     ///
-    int function (
-        _cef_extension_handler_t* self,
-        _cef_extension_t* extension,
-        _cef_browser_t* browser,
-        int include_incognito,
-        _cef_browser_t* target_browser) nothrow can_access_browser;
-
-    ///
-    // Called to retrieve an extension resource that would normally be loaded from
-    // disk (e.g. if a file parameter is specified to chrome.tabs.executeScript).
-    // |extension| and |browser| are the source of the resource request. |file| is
-    // the requested relative file path. To handle the resource request return
-    // true (1) and execute |callback| either synchronously or asynchronously. For
-    // the default behavior which reads the resource from the extension directory
-    // on disk return false (0). Localization substitutions will not be applied to
-    // resources handled via this function.
-    ///
-    int function (
-        _cef_extension_handler_t* self,
-        _cef_extension_t* extension,
-        _cef_browser_t* browser,
-        const(cef_string_t)* file,
-        _cef_get_extension_resource_callback_t* callback) nothrow get_extension_resource;
-}
-
-alias cef_extension_handler_t = _cef_extension_handler_t;
-
-// CEF_INCLUDE_CAPI_CEF_EXTENSION_HANDLER_CAPI_H_
+    extern(System) int function (
+        cef_v8interceptor_t* self,
+        int index,
+        cef_v8value_t* object,
+        cef_v8value_t* value,
+        cef_string_t* exception) nothrow set_byindex;
 }
 
 
-version(Windows):
-import arsd.simpledisplay;
-import arsd.com;
-import core.atomic;
 
-import std.stdio;
+///
+// Structure representing a V8 exception. The functions of this structure may be
+// called on any render process thread.
+///
+struct cef_v8exception_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
 
-T callback(T)(typeof(&T.init.Invoke) dg) {
-	return new class T {
-		extern(Windows):
+    ///
+    // Returns the exception message.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_v8exception_t* self) nothrow get_message;
 
-		static if(is(typeof(T.init.Invoke) R == return))
-		static if(is(typeof(T.init.Invoke) P == __parameters))
-  		override R Invoke(P _args_) {
-			return dg(_args_);
-		}
+    ///
+    // Returns the line of source code that the exception occurred within.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_v8exception_t* self) nothrow get_source_line;
 
-		override HRESULT QueryInterface(const (IID)*riid, LPVOID *ppv) {
-			if (IID_IUnknown == *riid) {
-				*ppv = cast(void*) cast(IUnknown) this;
-			}
-			else if (T.iid == *riid) {
-				*ppv = cast(void*) cast(T) this;
-			}
-			else {
-				*ppv = null;
-				return E_NOINTERFACE;
-			}
+    ///
+    // Returns the resource name for the script from where the function causing
+    // the error originates.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_v8exception_t* self) nothrow get_script_resource_name;
 
-			AddRef();
-			return NOERROR;
-		}
+    ///
+    // Returns the 1-based number of the line where the error occurred or 0 if the
+    // line number is unknown.
+    ///
+    extern(System) int function (cef_v8exception_t* self) nothrow get_line_number;
 
-		LONG count = 0;             // object reference count
-		ULONG AddRef() {
-			return atomicOp!"+="(*cast(shared)&count, 1);
-		}
-		ULONG Release() {
-			return atomicOp!"-="(*cast(shared)&count, 1);
-		}
-	};
+    ///
+    // Returns the index within the script of the first character where the error
+    // occurred.
+    ///
+    extern(System) int function (cef_v8exception_t* self) nothrow get_start_position;
+
+    ///
+    // Returns the index within the script of the last character where the error
+    // occurred.
+    ///
+    extern(System) int function (cef_v8exception_t* self) nothrow get_end_position;
+
+    ///
+    // Returns the index within the line of the first character where the error
+    // occurred.
+    ///
+    extern(System) int function (cef_v8exception_t* self) nothrow get_start_column;
+
+    ///
+    // Returns the index within the line of the last character where the error
+    // occurred.
+    ///
+    extern(System) int function (cef_v8exception_t* self) nothrow get_end_column;
 }
 
-version(Demo)
-void main() {
-	//CoInitializeEx(null, COINIT_APARTMENTTHREADED);
-
-	auto window = new SimpleWindow(500, 500, "Webview");//, OpenGlOptions.no, Resizability.allowResizing,;
-
-	auto lib = LoadLibraryW("WebView2Loader.dll"w.ptr);
-	typeof(&CreateCoreWebView2EnvironmentWithOptions) func;
-	assert(lib);
-	func = cast(typeof(func)) GetProcAddress(lib, CreateCoreWebView2EnvironmentWithOptions.mangleof);
-	assert(func);
-
-	ICoreWebView2 webview_window;
-	ICoreWebView2Environment webview_env;
-
-	auto result = func(null, null, null,
-		callback!(ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler)(
-			delegate(error, env) {
-				if(error)
-					return error;
-
-				webview_env = env;
-				env.AddRef();
-
-				env.CreateCoreWebView2Controller(window.impl.hwnd,
-					callback!(ICoreWebView2CreateCoreWebView2ControllerCompletedHandler)(delegate(error, controller) {
-						if(error || controller is null)
-							return error;
-						controller.AddRef();
-						error = controller.get_CoreWebView2(&webview_window);
-						webview_window.AddRef();
-
-						ICoreWebView2Settings Settings;
-						webview_window.get_Settings(&Settings);
-						Settings.put_IsScriptEnabled(TRUE);
-						Settings.put_AreDefaultScriptDialogsEnabled(TRUE);
-						Settings.put_IsWebMessageEnabled(TRUE);
 
 
-		EventRegistrationToken ert = EventRegistrationToken(233);
-		webview_window.add_NavigationStarting(
-			callback!(
-				ICoreWebView2NavigationStartingEventHandler,
-			)(delegate (sender, args) {
-				wchar* t;
-				args.get_Uri(&t);
-				auto ot = t;
+///
+// Callback structure that is passed to cef_v8value_t::CreateArrayBuffer.
+///
+struct cef_v8array_buffer_release_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
 
-				write("Nav: ");
-
-				while(*t) {
-					write(*t);
-					t++;
-				}
-
-				CoTaskMemFree(ot);
-
-				return S_OK;
-			})
-			, &ert);
-
-						RECT bounds;
-						GetClientRect(window.impl.hwnd, &bounds);
-						controller.put_Bounds(bounds);
-						error = webview_window.Navigate("https://bing.com/"w.ptr);
-						//error = webview_window.NavigateToString("<html><body>Hello</body></html>"w.ptr);
-						//error = webview_window.Navigate("http://192.168.1.10/"w.ptr);
-
-						controller.put_IsVisible(true);
-						writeln(error, " ", window.impl.hwnd, " window ", webview_window);//, "\n", GetParent(webview_window));
-
-						return S_OK;
-					}));
-
-
-				return S_OK;
-			}
-		)
-	);
-
-	if(result != S_OK) {
-		import std.stdio;
-		writeln("Failed: ", result);
-	}
-
-	window.eventLoop(0);
+    ///
+    // Called to release |buffer| when the ArrayBuffer JS object is garbage
+    // collected. |buffer| is the value that was passed to CreateArrayBuffer along
+    // with this object.
+    ///
+    extern(System) void function (
+        cef_v8array_buffer_release_callback_t* self,
+        void* buffer) nothrow release_buffer;
 }
 
 
+
+///
+// Structure representing a V8 value handle. V8 handles can only be accessed
+// from the thread on which they are created. Valid threads for creating a V8
+// handle include the render process main thread (TID_RENDERER) and WebWorker
+// threads. A task runner for posting tasks on the associated thread can be
+// retrieved via the cef_v8context_t::get_task_runner() function.
+///
+struct cef_v8value_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if the underlying handle is valid and it can be accessed
+    // on the current thread. Do not call any other functions if this function
+    // returns false (0).
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_valid;
+
+    ///
+    // True if the value type is undefined.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_undefined;
+
+    ///
+    // True if the value type is null.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_null;
+
+    ///
+    // True if the value type is bool.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_bool;
+
+    ///
+    // True if the value type is int.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_int;
+
+    ///
+    // True if the value type is unsigned int.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_uint;
+
+    ///
+    // True if the value type is double.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_double;
+
+    ///
+    // True if the value type is Date.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_date;
+
+    ///
+    // True if the value type is string.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_string;
+
+    ///
+    // True if the value type is object.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_object;
+
+    ///
+    // True if the value type is array.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_array;
+
+    ///
+    // True if the value type is an ArrayBuffer.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_array_buffer;
+
+    ///
+    // True if the value type is function.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_function;
+
+    ///
+    // Returns true (1) if this object is pointing to the same handle as |that|
+    // object.
+    ///
+    extern(System) int function (cef_v8value_t* self, cef_v8value_t* that) nothrow is_same;
+
+    ///
+    // Return a bool value.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow get_bool_value;
+
+    ///
+    // Return an int value.
+    ///
+    extern(System) int32 function (cef_v8value_t* self) nothrow get_int_value;
+
+    ///
+    // Return an unsigned int value.
+    ///
+    extern(System) uint32 function (cef_v8value_t* self) nothrow get_uint_value;
+
+    ///
+    // Return a double value.
+    ///
+    extern(System) double function (cef_v8value_t* self) nothrow get_double_value;
+
+    ///
+    // Return a Date value.
+    ///
+    extern(System) cef_time_t function (cef_v8value_t* self) nothrow get_date_value;
+
+    ///
+    // Return a string value.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_v8value_t* self) nothrow get_string_value;
+
+    // OBJECT METHODS - These functions are only available on objects. Arrays and
+    // functions are also objects. String- and integer-based keys can be used
+    // interchangably with the framework converting between them as necessary.
+
+    ///
+    // Returns true (1) if this is a user created object.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow is_user_created;
+
+    ///
+    // Returns true (1) if the last function call resulted in an exception. This
+    // attribute exists only in the scope of the current CEF value object.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow has_exception;
+
+    ///
+    // Returns the exception resulting from the last function call. This attribute
+    // exists only in the scope of the current CEF value object.
+    ///
+    extern(System) cef_v8exception_t* function (cef_v8value_t* self) nothrow get_exception;
+
+    ///
+    // Clears the last exception and returns true (1) on success.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow clear_exception;
+
+    ///
+    // Returns true (1) if this object will re-throw future exceptions. This
+    // attribute exists only in the scope of the current CEF value object.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow will_rethrow_exceptions;
+
+    ///
+    // Set whether this object will re-throw future exceptions. By default
+    // exceptions are not re-thrown. If a exception is re-thrown the current
+    // context should not be accessed again until after the exception has been
+    // caught and not re-thrown. Returns true (1) on success. This attribute
+    // exists only in the scope of the current CEF value object.
+    ///
+    extern(System) int function (cef_v8value_t* self, int rethrow) nothrow set_rethrow_exceptions;
+
+    ///
+    // Returns true (1) if the object has a value with the specified identifier.
+    ///
+    extern(System) int function (
+        cef_v8value_t* self,
+        const(cef_string_t)* key) nothrow has_value_bykey;
+
+    ///
+    // Returns true (1) if the object has a value with the specified identifier.
+    ///
+    extern(System) int function (cef_v8value_t* self, int index) nothrow has_value_byindex;
+
+    ///
+    // Deletes the value with the specified identifier and returns true (1) on
+    // success. Returns false (0) if this function is called incorrectly or an
+    // exception is thrown. For read-only and don't-delete values this function
+    // will return true (1) even though deletion failed.
+    ///
+    extern(System) int function (
+        cef_v8value_t* self,
+        const(cef_string_t)* key) nothrow delete_value_bykey;
+
+    ///
+    // Deletes the value with the specified identifier and returns true (1) on
+    // success. Returns false (0) if this function is called incorrectly, deletion
+    // fails or an exception is thrown. For read-only and don't-delete values this
+    // function will return true (1) even though deletion failed.
+    ///
+    extern(System) int function (cef_v8value_t* self, int index) nothrow delete_value_byindex;
+
+    ///
+    // Returns the value with the specified identifier on success. Returns NULL if
+    // this function is called incorrectly or an exception is thrown.
+    ///
+    extern(System) cef_v8value_t* function (
+        cef_v8value_t* self,
+        const(cef_string_t)* key) nothrow get_value_bykey;
+
+    ///
+    // Returns the value with the specified identifier on success. Returns NULL if
+    // this function is called incorrectly or an exception is thrown.
+    ///
+    extern(System) cef_v8value_t* function (
+        cef_v8value_t* self,
+        int index) nothrow get_value_byindex;
+
+    ///
+    // Associates a value with the specified identifier and returns true (1) on
+    // success. Returns false (0) if this function is called incorrectly or an
+    // exception is thrown. For read-only values this function will return true
+    // (1) even though assignment failed.
+    ///
+    extern(System) int function (
+        cef_v8value_t* self,
+        const(cef_string_t)* key,
+        cef_v8value_t* value,
+        cef_v8_propertyattribute_t attribute) nothrow set_value_bykey;
+
+    ///
+    // Associates a value with the specified identifier and returns true (1) on
+    // success. Returns false (0) if this function is called incorrectly or an
+    // exception is thrown. For read-only values this function will return true
+    // (1) even though assignment failed.
+    ///
+    extern(System) int function (
+        cef_v8value_t* self,
+        int index,
+        cef_v8value_t* value) nothrow set_value_byindex;
+
+    ///
+    // Registers an identifier and returns true (1) on success. Access to the
+    // identifier will be forwarded to the cef_v8accessor_t instance passed to
+    // cef_v8value_t::cef_v8value_create_object(). Returns false (0) if this
+    // function is called incorrectly or an exception is thrown. For read-only
+    // values this function will return true (1) even though assignment failed.
+    ///
+    extern(System) int function (
+        cef_v8value_t* self,
+        const(cef_string_t)* key,
+        cef_v8_accesscontrol_t settings,
+        cef_v8_propertyattribute_t attribute) nothrow set_value_byaccessor;
+
+    ///
+    // Read the keys for the object's values into the specified vector. Integer-
+    // based keys will also be returned as strings.
+    ///
+    extern(System) int function (cef_v8value_t* self, cef_string_list_t keys) nothrow get_keys;
+
+    ///
+    // Sets the user data for this object and returns true (1) on success. Returns
+    // false (0) if this function is called incorrectly. This function can only be
+    // called on user created objects.
+    ///
+    extern(System) int function (
+        cef_v8value_t* self,
+        cef_base_ref_counted_t* user_data) nothrow set_user_data;
+
+    ///
+    // Returns the user data, if any, assigned to this object.
+    ///
+    extern(System) cef_base_ref_counted_t* function (cef_v8value_t* self) nothrow get_user_data;
+
+    ///
+    // Returns the amount of externally allocated memory registered for the
+    // object.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow get_externally_allocated_memory;
+
+    ///
+    // Adjusts the amount of registered external memory for the object. Used to
+    // give V8 an indication of the amount of externally allocated memory that is
+    // kept alive by JavaScript objects. V8 uses this information to decide when
+    // to perform global garbage collection. Each cef_v8value_t tracks the amount
+    // of external memory associated with it and automatically decreases the
+    // global total by the appropriate amount on its destruction.
+    // |change_in_bytes| specifies the number of bytes to adjust by. This function
+    // returns the number of bytes associated with the object after the
+    // adjustment. This function can only be called on user created objects.
+    ///
+    extern(System) int function (
+        cef_v8value_t* self,
+        int change_in_bytes) nothrow adjust_externally_allocated_memory;
+
+    // ARRAY METHODS - These functions are only available on arrays.
+
+    ///
+    // Returns the number of elements in the array.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow get_array_length;
+
+    // ARRAY BUFFER METHODS - These functions are only available on ArrayBuffers.
+
+    ///
+    // Returns the ReleaseCallback object associated with the ArrayBuffer or NULL
+    // if the ArrayBuffer was not created with CreateArrayBuffer.
+    ///
+    extern(System) cef_v8array_buffer_release_callback_t* function (
+        cef_v8value_t* self) nothrow get_array_buffer_release_callback;
+
+    ///
+    // Prevent the ArrayBuffer from using it's memory block by setting the length
+    // to zero. This operation cannot be undone. If the ArrayBuffer was created
+    // with CreateArrayBuffer then
+    // cef_v8array_buffer_release_callback_t::ReleaseBuffer will be called to
+    // release the underlying buffer.
+    ///
+    extern(System) int function (cef_v8value_t* self) nothrow neuter_array_buffer;
+
+    // FUNCTION METHODS - These functions are only available on functions.
+
+    ///
+    // Returns the function name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_v8value_t* self) nothrow get_function_name;
+
+    ///
+    // Returns the function handler or NULL if not a CEF-created function.
+    ///
+    extern(System) cef_v8handler_t* function (cef_v8value_t* self) nothrow get_function_handler;
+
+    ///
+    // Execute the function using the current V8 context. This function should
+    // only be called from within the scope of a cef_v8handler_t or
+    // cef_v8accessor_t callback, or in combination with calling enter() and
+    // exit() on a stored cef_v8context_t reference. |object| is the receiver
+    // ('this' object) of the function. If |object| is NULL the current context's
+    // global object will be used. |arguments| is the list of arguments that will
+    // be passed to the function. Returns the function return value on success.
+    // Returns NULL if this function is called incorrectly or an exception is
+    // thrown.
+    ///
+    extern(System) cef_v8value_t* function (
+        cef_v8value_t* self,
+        cef_v8value_t* object,
+        size_t argumentsCount,
+        cef_v8value_t** arguments) nothrow execute_function;
+
+    ///
+    // Execute the function using the specified V8 context. |object| is the
+    // receiver ('this' object) of the function. If |object| is NULL the specified
+    // context's global object will be used. |arguments| is the list of arguments
+    // that will be passed to the function. Returns the function return value on
+    // success. Returns NULL if this function is called incorrectly or an
+    // exception is thrown.
+    ///
+    extern(System) cef_v8value_t* function (
+        cef_v8value_t* self,
+        cef_v8context_t* context,
+        cef_v8value_t* object,
+        size_t argumentsCount,
+        cef_v8value_t** arguments) nothrow execute_function_with_context;
+}
+
+
+
+///
+// Create a new cef_v8value_t object of type undefined.
+///
+cef_v8value_t* cef_v8value_create_undefined ();
+
+///
+// Create a new cef_v8value_t object of type null.
+///
+cef_v8value_t* cef_v8value_create_null ();
+
+///
+// Create a new cef_v8value_t object of type bool.
+///
+cef_v8value_t* cef_v8value_create_bool (int value);
+
+///
+// Create a new cef_v8value_t object of type int.
+///
+cef_v8value_t* cef_v8value_create_int (int32 value);
+
+///
+// Create a new cef_v8value_t object of type unsigned int.
+///
+cef_v8value_t* cef_v8value_create_uint (uint32 value);
+
+///
+// Create a new cef_v8value_t object of type double.
+///
+cef_v8value_t* cef_v8value_create_double (double value);
+
+///
+// Create a new cef_v8value_t object of type Date. This function should only be
+// called from within the scope of a cef_render_process_handler_t,
+// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling
+// enter() and exit() on a stored cef_v8context_t reference.
+///
+cef_v8value_t* cef_v8value_create_date (const(cef_time_t)* date);
+
+///
+// Create a new cef_v8value_t object of type string.
+///
+cef_v8value_t* cef_v8value_create_string (const(cef_string_t)* value);
+
+///
+// Create a new cef_v8value_t object of type object with optional accessor
+// and/or interceptor. This function should only be called from within the scope
+// of a cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t
+// callback, or in combination with calling enter() and exit() on a stored
+// cef_v8context_t reference.
+///
+cef_v8value_t* cef_v8value_create_object (
+    cef_v8accessor_t* accessor,
+    cef_v8interceptor_t* interceptor);
+
+///
+// Create a new cef_v8value_t object of type array with the specified |length|.
+// If |length| is negative the returned array will have length 0. This function
+// should only be called from within the scope of a
+// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback,
+// or in combination with calling enter() and exit() on a stored cef_v8context_t
+// reference.
+///
+cef_v8value_t* cef_v8value_create_array (int length);
+
+///
+// Create a new cef_v8value_t object of type ArrayBuffer which wraps the
+// provided |buffer| of size |length| bytes. The ArrayBuffer is externalized,
+// meaning that it does not own |buffer|. The caller is responsible for freeing
+// |buffer| when requested via a call to cef_v8array_buffer_release_callback_t::
+// ReleaseBuffer. This function should only be called from within the scope of a
+// cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback,
+// or in combination with calling enter() and exit() on a stored cef_v8context_t
+// reference.
+///
+cef_v8value_t* cef_v8value_create_array_buffer (
+    void* buffer,
+    size_t length,
+    cef_v8array_buffer_release_callback_t* release_callback);
+
+///
+// Create a new cef_v8value_t object of type function. This function should only
+// be called from within the scope of a cef_render_process_handler_t,
+// cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling
+// enter() and exit() on a stored cef_v8context_t reference.
+///
+extern(System) cef_v8value_t* cef_v8value_create_function (
+    const(cef_string_t)* name,
+    cef_v8handler_t* handler) nothrow;
+
+///
+// Structure representing a V8 stack trace handle. V8 handles can only be
+// accessed from the thread on which they are created. Valid threads for
+// creating a V8 handle include the render process main thread (TID_RENDERER)
+// and WebWorker threads. A task runner for posting tasks on the associated
+// thread can be retrieved via the cef_v8context_t::get_task_runner() function.
+///
+struct cef_v8stack_trace_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if the underlying handle is valid and it can be accessed
+    // on the current thread. Do not call any other functions if this function
+    // returns false (0).
+    ///
+    extern(System) int function (cef_v8stack_trace_t* self) nothrow is_valid;
+
+    ///
+    // Returns the number of stack frames.
+    ///
+    extern(System) int function (cef_v8stack_trace_t* self) nothrow get_frame_count;
+
+    ///
+    // Returns the stack frame at the specified 0-based index.
+    ///
+    extern(System) cef_v8stack_frame_t* function (
+        cef_v8stack_trace_t* self,
+        int index) nothrow get_frame;
+}
+
+
+
+///
+// Returns the stack trace for the currently active context. |frame_limit| is
+// the maximum number of frames that will be captured.
+///
+cef_v8stack_trace_t* cef_v8stack_trace_get_current (int frame_limit);
+
+///
+// Structure representing a V8 stack frame handle. V8 handles can only be
+// accessed from the thread on which they are created. Valid threads for
+// creating a V8 handle include the render process main thread (TID_RENDERER)
+// and WebWorker threads. A task runner for posting tasks on the associated
+// thread can be retrieved via the cef_v8context_t::get_task_runner() function.
+///
+struct cef_v8stack_frame_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if the underlying handle is valid and it can be accessed
+    // on the current thread. Do not call any other functions if this function
+    // returns false (0).
+    ///
+    extern(System) int function (cef_v8stack_frame_t* self) nothrow is_valid;
+
+    ///
+    // Returns the name of the resource script that contains the function.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_v8stack_frame_t* self) nothrow get_script_name;
+
+    ///
+    // Returns the name of the resource script that contains the function or the
+    // sourceURL value if the script name is undefined and its source ends with a
+    // "//@ sourceURL=..." string.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_v8stack_frame_t* self) nothrow get_script_name_or_source_url;
+
+    ///
+    // Returns the name of the function.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_v8stack_frame_t* self) nothrow get_function_name;
+
+    ///
+    // Returns the 1-based line number for the function call or 0 if unknown.
+    ///
+    extern(System) int function (cef_v8stack_frame_t* self) nothrow get_line_number;
+
+    ///
+    // Returns the 1-based column offset on the line for the function call or 0 if
+    // unknown.
+    ///
+    extern(System) int function (cef_v8stack_frame_t* self) nothrow get_column;
+
+    ///
+    // Returns true (1) if the function was compiled using eval().
+    ///
+    extern(System) int function (cef_v8stack_frame_t* self) nothrow is_eval;
+
+    ///
+    // Returns true (1) if the function was called as a constructor via "new".
+    ///
+    extern(System) int function (cef_v8stack_frame_t* self) nothrow is_constructor;
+}
+
+
+
+///
+// Register a new V8 extension with the specified JavaScript extension code and
+// handler. Functions implemented by the handler are prototyped using the
+// keyword 'native'. The calling of a native function is restricted to the scope
+// in which the prototype of the native function is defined. This function may
+// only be called on the render process main thread.
+//
+// Example JavaScript extension code: <pre>
+//   // create the 'example' global object if it doesn't already exist.
+//   if (!example)
+//     example = {};
+//   // create the 'example.test' global object if it doesn't already exist.
+//   if (!example.test)
+//     example.test = {};
+//   (function() {
+//     // Define the function 'example.test.myfunction'.
+//     example.test.myfunction = function() {
+//       // Call CefV8Handler::Execute() with the function name 'MyFunction'
+//       // and no arguments.
+//       native function MyFunction();
+//       return MyFunction();
+//     };
+//     // Define the getter function for parameter 'example.test.myparam'.
+//     example.test.__defineGetter__('myparam', function() {
+//       // Call CefV8Handler::Execute() with the function name 'GetMyParam'
+//       // and no arguments.
+//       native function GetMyParam();
+//       return GetMyParam();
+//     });
+//     // Define the setter function for parameter 'example.test.myparam'.
+//     example.test.__defineSetter__('myparam', function(b) {
+//       // Call CefV8Handler::Execute() with the function name 'SetMyParam'
+//       // and a single argument.
+//       native function SetMyParam();
+//       if(b) SetMyParam(b);
+//     });
+//
+//     // Extension definitions can also contain normal JavaScript variables
+//     // and functions.
+//     var myint = 0;
+//     example.test.increment = function() {
+//       myint += 1;
+//       return myint;
+//     };
+//   })();
+// </pre> Example usage in the page: <pre>
+//   // Call the function.
+//   example.test.myfunction();
+//   // Set the parameter.
+//   example.test.myparam = value;
+//   // Get the parameter.
+//   value = example.test.myparam;
+//   // Call another function.
+//   example.test.increment();
+// </pre>
+///
+int cef_register_extension (
+    const(cef_string_t)* extension_name,
+    const(cef_string_t)* javascript_code,
+    cef_v8handler_t* handler);
+
+// CEF_INCLUDE_CAPI_CEF_V8_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=d9074be0e6960c69cfe2c39b92b4dd6f529210d1$
+//
+
+extern (C):
+
+///
+// Structure that wraps other data value types. Complex types (binary,
+// dictionary and list) will be referenced but not owned by this object. Can be
+// used on any process and thread.
+///
+struct cef_value_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if the underlying data is valid. This will always be true
+    // (1) for simple types. For complex types (binary, dictionary and list) the
+    // underlying data may become invalid if owned by another object (e.g. list or
+    // dictionary) and that other object is then modified or destroyed. This value
+    // object can be re-used by calling Set*() even if the underlying data is
+    // invalid.
+    ///
+    extern(System) int function (cef_value_t* self) nothrow is_valid;
+
+    ///
+    // Returns true (1) if the underlying data is owned by another object.
+    ///
+    extern(System) int function (cef_value_t* self) nothrow is_owned;
+
+    ///
+    // Returns true (1) if the underlying data is read-only. Some APIs may expose
+    // read-only objects.
+    ///
+    extern(System) int function (cef_value_t* self) nothrow is_read_only;
+
+    ///
+    // Returns true (1) if this object and |that| object have the same underlying
+    // data. If true (1) modifications to this object will also affect |that|
+    // object and vice-versa.
+    ///
+    extern(System) int function (cef_value_t* self, cef_value_t* that) nothrow is_same;
+
+    ///
+    // Returns true (1) if this object and |that| object have an equivalent
+    // underlying value but are not necessarily the same object.
+    ///
+    extern(System) int function (cef_value_t* self, cef_value_t* that) nothrow is_equal;
+
+    ///
+    // Returns a copy of this object. The underlying data will also be copied.
+    ///
+    extern(System) cef_value_t* function (cef_value_t* self) nothrow copy;
+
+    ///
+    // Returns the underlying value type.
+    ///
+    extern(System) cef_value_type_t function (cef_value_t* self) nothrow get_type;
+
+    ///
+    // Returns the underlying value as type bool.
+    ///
+    extern(System) int function (cef_value_t* self) nothrow get_bool;
+
+    ///
+    // Returns the underlying value as type int.
+    ///
+    extern(System) int function (cef_value_t* self) nothrow get_int;
+
+    ///
+    // Returns the underlying value as type double.
+    ///
+    extern(System) double function (cef_value_t* self) nothrow get_double;
+
+    ///
+    // Returns the underlying value as type string.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_value_t* self) nothrow get_string;
+
+    ///
+    // Returns the underlying value as type binary. The returned reference may
+    // become invalid if the value is owned by another object or if ownership is
+    // transferred to another object in the future. To maintain a reference to the
+    // value after assigning ownership to a dictionary or list pass this object to
+    // the set_value() function instead of passing the returned reference to
+    // set_binary().
+    ///
+    extern(System) cef_binary_value_t* function (cef_value_t* self) nothrow get_binary;
+
+    ///
+    // Returns the underlying value as type dictionary. The returned reference may
+    // become invalid if the value is owned by another object or if ownership is
+    // transferred to another object in the future. To maintain a reference to the
+    // value after assigning ownership to a dictionary or list pass this object to
+    // the set_value() function instead of passing the returned reference to
+    // set_dictionary().
+    ///
+    extern(System) cef_dictionary_value_t* function (cef_value_t* self) nothrow get_dictionary;
+
+    ///
+    // Returns the underlying value as type list. The returned reference may
+    // become invalid if the value is owned by another object or if ownership is
+    // transferred to another object in the future. To maintain a reference to the
+    // value after assigning ownership to a dictionary or list pass this object to
+    // the set_value() function instead of passing the returned reference to
+    // set_list().
+    ///
+    extern(System) cef_list_value_t* function (cef_value_t* self) nothrow get_list;
+
+    ///
+    // Sets the underlying value as type null. Returns true (1) if the value was
+    // set successfully.
+    ///
+    extern(System) int function (cef_value_t* self) nothrow set_null;
+
+    ///
+    // Sets the underlying value as type bool. Returns true (1) if the value was
+    // set successfully.
+    ///
+    extern(System) int function (cef_value_t* self, int value) nothrow set_bool;
+
+    ///
+    // Sets the underlying value as type int. Returns true (1) if the value was
+    // set successfully.
+    ///
+    extern(System) int function (cef_value_t* self, int value) nothrow set_int;
+
+    ///
+    // Sets the underlying value as type double. Returns true (1) if the value was
+    // set successfully.
+    ///
+    extern(System) int function (cef_value_t* self, double value) nothrow set_double;
+
+    ///
+    // Sets the underlying value as type string. Returns true (1) if the value was
+    // set successfully.
+    ///
+    extern(System) int function (cef_value_t* self, const(cef_string_t)* value) nothrow set_string;
+
+    ///
+    // Sets the underlying value as type binary. Returns true (1) if the value was
+    // set successfully. This object keeps a reference to |value| and ownership of
+    // the underlying data remains unchanged.
+    ///
+    extern(System) int function (cef_value_t* self, cef_binary_value_t* value) nothrow set_binary;
+
+    ///
+    // Sets the underlying value as type dict. Returns true (1) if the value was
+    // set successfully. This object keeps a reference to |value| and ownership of
+    // the underlying data remains unchanged.
+    ///
+    extern(System) int function (
+        cef_value_t* self,
+        cef_dictionary_value_t* value) nothrow set_dictionary;
+
+    ///
+    // Sets the underlying value as type list. Returns true (1) if the value was
+    // set successfully. This object keeps a reference to |value| and ownership of
+    // the underlying data remains unchanged.
+    ///
+    extern(System) int function (cef_value_t* self, cef_list_value_t* value) nothrow set_list;
+}
+
+
+
+///
+// Creates a new object.
+///
+cef_value_t* cef_value_create ();
+
+///
+// Structure representing a binary value. Can be used on any process and thread.
+///
+struct cef_binary_value_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is valid. This object may become invalid if
+    // the underlying data is owned by another object (e.g. list or dictionary)
+    // and that other object is then modified or destroyed. Do not call any other
+    // functions if this function returns false (0).
+    ///
+    extern(System) int function (cef_binary_value_t* self) nothrow is_valid;
+
+    ///
+    // Returns true (1) if this object is currently owned by another object.
+    ///
+    extern(System) int function (cef_binary_value_t* self) nothrow is_owned;
+
+    ///
+    // Returns true (1) if this object and |that| object have the same underlying
+    // data.
+    ///
+    extern(System) int function (
+        cef_binary_value_t* self,
+        cef_binary_value_t* that) nothrow is_same;
+
+    ///
+    // Returns true (1) if this object and |that| object have an equivalent
+    // underlying value but are not necessarily the same object.
+    ///
+    extern(System) int function (
+        cef_binary_value_t* self,
+        cef_binary_value_t* that) nothrow is_equal;
+
+    ///
+    // Returns a copy of this object. The data in this object will also be copied.
+    ///
+    extern(System) cef_binary_value_t* function (cef_binary_value_t* self) nothrow copy;
+
+    ///
+    // Returns the data size.
+    ///
+    extern(System) size_t function (cef_binary_value_t* self) nothrow get_size;
+
+    ///
+    // Read up to |buffer_size| number of bytes into |buffer|. Reading begins at
+    // the specified byte |data_offset|. Returns the number of bytes read.
+    ///
+    extern(System) size_t function (
+        cef_binary_value_t* self,
+        void* buffer,
+        size_t buffer_size,
+        size_t data_offset) nothrow get_data;
+}
+
+
+
+///
+// Creates a new object that is not owned by any other object. The specified
+// |data| will be copied.
+///
+cef_binary_value_t* cef_binary_value_create (
+    const(void)* data,
+    size_t data_size);
+
+///
+// Structure representing a dictionary value. Can be used on any process and
+// thread.
+///
+struct cef_dictionary_value_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is valid. This object may become invalid if
+    // the underlying data is owned by another object (e.g. list or dictionary)
+    // and that other object is then modified or destroyed. Do not call any other
+    // functions if this function returns false (0).
+    ///
+    extern(System) int function (cef_dictionary_value_t* self) nothrow is_valid;
+
+    ///
+    // Returns true (1) if this object is currently owned by another object.
+    ///
+    extern(System) int function (cef_dictionary_value_t* self) nothrow is_owned;
+
+    ///
+    // Returns true (1) if the values of this object are read-only. Some APIs may
+    // expose read-only objects.
+    ///
+    extern(System) int function (cef_dictionary_value_t* self) nothrow is_read_only;
+
+    ///
+    // Returns true (1) if this object and |that| object have the same underlying
+    // data. If true (1) modifications to this object will also affect |that|
+    // object and vice-versa.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        cef_dictionary_value_t* that) nothrow is_same;
+
+    ///
+    // Returns true (1) if this object and |that| object have an equivalent
+    // underlying value but are not necessarily the same object.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        cef_dictionary_value_t* that) nothrow is_equal;
+
+    ///
+    // Returns a writable copy of this object. If |exclude_NULL_children| is true
+    // (1) any NULL dictionaries or lists will be excluded from the copy.
+    ///
+    extern(System) cef_dictionary_value_t* function (
+        cef_dictionary_value_t* self,
+        int exclude_empty_children) nothrow copy;
+
+    ///
+    // Returns the number of values.
+    ///
+    extern(System) size_t function (cef_dictionary_value_t* self) nothrow get_size;
+
+    ///
+    // Removes all values. Returns true (1) on success.
+    ///
+    extern(System) int function (cef_dictionary_value_t* self) nothrow clear;
+
+    ///
+    // Returns true (1) if the current dictionary has a value for the given key.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow has_key;
+
+    ///
+    // Reads all keys for this dictionary into the specified vector.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        cef_string_list_t keys) nothrow get_keys;
+
+    ///
+    // Removes the value at the specified key. Returns true (1) is the value was
+    // removed successfully.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow remove;
+
+    ///
+    // Returns the value type for the specified key.
+    ///
+    extern(System) cef_value_type_t function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow get_type;
+
+    ///
+    // Returns the value at the specified key. For simple types the returned value
+    // will copy existing data and modifications to the value will not modify this
+    // object. For complex types (binary, dictionary and list) the returned value
+    // will reference existing data and modifications to the value will modify
+    // this object.
+    ///
+    extern(System) cef_value_t* function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow get_value;
+
+    ///
+    // Returns the value at the specified key as type bool.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow get_bool;
+
+    ///
+    // Returns the value at the specified key as type int.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow get_int;
+
+    ///
+    // Returns the value at the specified key as type double.
+    ///
+    extern(System) double function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow get_double;
+
+    ///
+    // Returns the value at the specified key as type string.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow get_string;
+
+    ///
+    // Returns the value at the specified key as type binary. The returned value
+    // will reference existing data.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow get_binary;
+
+    ///
+    // Returns the value at the specified key as type dictionary. The returned
+    // value will reference existing data and modifications to the value will
+    // modify this object.
+    ///
+    extern(System) cef_dictionary_value_t* function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow get_dictionary;
+
+    ///
+    // Returns the value at the specified key as type list. The returned value
+    // will reference existing data and modifications to the value will modify
+    // this object.
+    ///
+    extern(System) cef_list_value_t* function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow get_list;
+
+    ///
+    // Sets the value at the specified key. Returns true (1) if the value was set
+    // successfully. If |value| represents simple data then the underlying data
+    // will be copied and modifications to |value| will not modify this object. If
+    // |value| represents complex data (binary, dictionary or list) then the
+    // underlying data will be referenced and modifications to |value| will modify
+    // this object.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key,
+        cef_value_t* value) nothrow set_value;
+
+    ///
+    // Sets the value at the specified key as type null. Returns true (1) if the
+    // value was set successfully.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key) nothrow set_null;
+
+    ///
+    // Sets the value at the specified key as type bool. Returns true (1) if the
+    // value was set successfully.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key,
+        int value) nothrow set_bool;
+
+    ///
+    // Sets the value at the specified key as type int. Returns true (1) if the
+    // value was set successfully.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key,
+        int value) nothrow set_int;
+
+    ///
+    // Sets the value at the specified key as type double. Returns true (1) if the
+    // value was set successfully.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key,
+        double value) nothrow set_double;
+
+    ///
+    // Sets the value at the specified key as type string. Returns true (1) if the
+    // value was set successfully.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key,
+        const(cef_string_t)* value) nothrow set_string;
+
+    ///
+    // Sets the value at the specified key as type binary. Returns true (1) if the
+    // value was set successfully. If |value| is currently owned by another object
+    // then the value will be copied and the |value| reference will not change.
+    // Otherwise, ownership will be transferred to this object and the |value|
+    // reference will be invalidated.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key,
+        cef_binary_value_t* value) nothrow set_binary;
+
+    ///
+    // Sets the value at the specified key as type dict. Returns true (1) if the
+    // value was set successfully. If |value| is currently owned by another object
+    // then the value will be copied and the |value| reference will not change.
+    // Otherwise, ownership will be transferred to this object and the |value|
+    // reference will be invalidated.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key,
+        cef_dictionary_value_t* value) nothrow set_dictionary;
+
+    ///
+    // Sets the value at the specified key as type list. Returns true (1) if the
+    // value was set successfully. If |value| is currently owned by another object
+    // then the value will be copied and the |value| reference will not change.
+    // Otherwise, ownership will be transferred to this object and the |value|
+    // reference will be invalidated.
+    ///
+    extern(System) int function (
+        cef_dictionary_value_t* self,
+        const(cef_string_t)* key,
+        cef_list_value_t* value) nothrow set_list;
+}
+
+
+
+///
+// Creates a new object that is not owned by any other object.
+///
+cef_dictionary_value_t* cef_dictionary_value_create ();
+
+///
+// Structure representing a list value. Can be used on any process and thread.
+///
+struct cef_list_value_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns true (1) if this object is valid. This object may become invalid if
+    // the underlying data is owned by another object (e.g. list or dictionary)
+    // and that other object is then modified or destroyed. Do not call any other
+    // functions if this function returns false (0).
+    ///
+    extern(System) int function (cef_list_value_t* self) nothrow is_valid;
+
+    ///
+    // Returns true (1) if this object is currently owned by another object.
+    ///
+    extern(System) int function (cef_list_value_t* self) nothrow is_owned;
+
+    ///
+    // Returns true (1) if the values of this object are read-only. Some APIs may
+    // expose read-only objects.
+    ///
+    extern(System) int function (cef_list_value_t* self) nothrow is_read_only;
+
+    ///
+    // Returns true (1) if this object and |that| object have the same underlying
+    // data. If true (1) modifications to this object will also affect |that|
+    // object and vice-versa.
+    ///
+    extern(System) int function (cef_list_value_t* self, cef_list_value_t* that) nothrow is_same;
+
+    ///
+    // Returns true (1) if this object and |that| object have an equivalent
+    // underlying value but are not necessarily the same object.
+    ///
+    extern(System) int function (cef_list_value_t* self, cef_list_value_t* that) nothrow is_equal;
+
+    ///
+    // Returns a writable copy of this object.
+    ///
+    extern(System) cef_list_value_t* function (cef_list_value_t* self) nothrow copy;
+
+    ///
+    // Sets the number of values. If the number of values is expanded all new
+    // value slots will default to type null. Returns true (1) on success.
+    ///
+    extern(System) int function (cef_list_value_t* self, size_t size) nothrow set_size;
+
+    ///
+    // Returns the number of values.
+    ///
+    extern(System) size_t function (cef_list_value_t* self) nothrow get_size;
+
+    ///
+    // Removes all values. Returns true (1) on success.
+    ///
+    extern(System) int function (cef_list_value_t* self) nothrow clear;
+
+    ///
+    // Removes the value at the specified index.
+    ///
+    extern(System) int function (cef_list_value_t* self, size_t index) nothrow remove;
+
+    ///
+    // Returns the value type at the specified index.
+    ///
+    extern(System) cef_value_type_t function (cef_list_value_t* self, size_t index) nothrow get_type;
+
+    ///
+    // Returns the value at the specified index. For simple types the returned
+    // value will copy existing data and modifications to the value will not
+    // modify this object. For complex types (binary, dictionary and list) the
+    // returned value will reference existing data and modifications to the value
+    // will modify this object.
+    ///
+    extern(System) cef_value_t* function (cef_list_value_t* self, size_t index) nothrow get_value;
+
+    ///
+    // Returns the value at the specified index as type bool.
+    ///
+    extern(System) int function (cef_list_value_t* self, size_t index) nothrow get_bool;
+
+    ///
+    // Returns the value at the specified index as type int.
+    ///
+    extern(System) int function (cef_list_value_t* self, size_t index) nothrow get_int;
+
+    ///
+    // Returns the value at the specified index as type double.
+    ///
+    extern(System) double function (cef_list_value_t* self, size_t index) nothrow get_double;
+
+    ///
+    // Returns the value at the specified index as type string.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_list_value_t* self,
+        size_t index) nothrow get_string;
+
+    ///
+    // Returns the value at the specified index as type binary. The returned value
+    // will reference existing data.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_list_value_t* self,
+        size_t index) nothrow get_binary;
+
+    ///
+    // Returns the value at the specified index as type dictionary. The returned
+    // value will reference existing data and modifications to the value will
+    // modify this object.
+    ///
+    extern(System) cef_dictionary_value_t* function (
+        cef_list_value_t* self,
+        size_t index) nothrow get_dictionary;
+
+    ///
+    // Returns the value at the specified index as type list. The returned value
+    // will reference existing data and modifications to the value will modify
+    // this object.
+    ///
+    extern(System) cef_list_value_t* function (
+        cef_list_value_t* self,
+        size_t index) nothrow get_list;
+
+    ///
+    // Sets the value at the specified index. Returns true (1) if the value was
+    // set successfully. If |value| represents simple data then the underlying
+    // data will be copied and modifications to |value| will not modify this
+    // object. If |value| represents complex data (binary, dictionary or list)
+    // then the underlying data will be referenced and modifications to |value|
+    // will modify this object.
+    ///
+    extern(System) int function (
+        cef_list_value_t* self,
+        size_t index,
+        cef_value_t* value) nothrow set_value;
+
+    ///
+    // Sets the value at the specified index as type null. Returns true (1) if the
+    // value was set successfully.
+    ///
+    extern(System) int function (cef_list_value_t* self, size_t index) nothrow set_null;
+
+    ///
+    // Sets the value at the specified index as type bool. Returns true (1) if the
+    // value was set successfully.
+    ///
+    extern(System) int function (cef_list_value_t* self, size_t index, int value) nothrow set_bool;
+
+    ///
+    // Sets the value at the specified index as type int. Returns true (1) if the
+    // value was set successfully.
+    ///
+    extern(System) int function (cef_list_value_t* self, size_t index, int value) nothrow set_int;
+
+    ///
+    // Sets the value at the specified index as type double. Returns true (1) if
+    // the value was set successfully.
+    ///
+    extern(System) int function (
+        cef_list_value_t* self,
+        size_t index,
+        double value) nothrow set_double;
+
+    ///
+    // Sets the value at the specified index as type string. Returns true (1) if
+    // the value was set successfully.
+    ///
+    extern(System) int function (
+        cef_list_value_t* self,
+        size_t index,
+        const(cef_string_t)* value) nothrow set_string;
+
+    ///
+    // Sets the value at the specified index as type binary. Returns true (1) if
+    // the value was set successfully. If |value| is currently owned by another
+    // object then the value will be copied and the |value| reference will not
+    // change. Otherwise, ownership will be transferred to this object and the
+    // |value| reference will be invalidated.
+    ///
+    extern(System) int function (
+        cef_list_value_t* self,
+        size_t index,
+        cef_binary_value_t* value) nothrow set_binary;
+
+    ///
+    // Sets the value at the specified index as type dict. Returns true (1) if the
+    // value was set successfully. If |value| is currently owned by another object
+    // then the value will be copied and the |value| reference will not change.
+    // Otherwise, ownership will be transferred to this object and the |value|
+    // reference will be invalidated.
+    ///
+    extern(System) int function (
+        cef_list_value_t* self,
+        size_t index,
+        cef_dictionary_value_t* value) nothrow set_dictionary;
+
+    ///
+    // Sets the value at the specified index as type list. Returns true (1) if the
+    // value was set successfully. If |value| is currently owned by another object
+    // then the value will be copied and the |value| reference will not change.
+    // Otherwise, ownership will be transferred to this object and the |value|
+    // reference will be invalidated.
+    ///
+    extern(System) int function (
+        cef_list_value_t* self,
+        size_t index,
+        cef_list_value_t* value) nothrow set_list;
+}
+
+
+
+///
+// Creates a new object that is not owned by any other object.
+///
+cef_list_value_t* cef_list_value_create ();
+
+// CEF_INCLUDE_CAPI_CEF_VALUES_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=ed698ff6cb09ee2ed87614e2733c742db827ed4f$
+//
+
+extern (C):
+
+///
+// WaitableEvent is a thread synchronization tool that allows one thread to wait
+// for another thread to finish some work. This is equivalent to using a
+// Lock+ConditionVariable to protect a simple boolean value. However, using
+// WaitableEvent in conjunction with a Lock to wait for a more complex state
+// change (e.g., for an item to be added to a queue) is not recommended. In that
+// case consider using a ConditionVariable instead of a WaitableEvent. It is
+// safe to create and/or signal a WaitableEvent from any thread. Blocking on a
+// WaitableEvent by calling the *wait() functions is not allowed on the browser
+// process UI or IO threads.
+///
+struct cef_waitable_event_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Put the event in the un-signaled state.
+    ///
+    extern(System) void function (cef_waitable_event_t* self) nothrow reset;
+
+    ///
+    // Put the event in the signaled state. This causes any thread blocked on Wait
+    // to be woken up.
+    ///
+    extern(System) void function (cef_waitable_event_t* self) nothrow signal;
+
+    ///
+    // Returns true (1) if the event is in the signaled state, else false (0). If
+    // the event was created with |automatic_reset| set to true (1) then calling
+    // this function will also cause a reset.
+    ///
+    extern(System) int function (cef_waitable_event_t* self) nothrow is_signaled;
+
+    ///
+    // Wait indefinitely for the event to be signaled. This function will not
+    // return until after the call to signal() has completed. This function cannot
+    // be called on the browser process UI or IO threads.
+    ///
+    extern(System) void function (cef_waitable_event_t* self) nothrow wait;
+
+    ///
+    // Wait up to |max_ms| milliseconds for the event to be signaled. Returns true
+    // (1) if the event was signaled. A return value of false (0) does not
+    // necessarily mean that |max_ms| was exceeded. This function will not return
+    // until after the call to signal() has completed. This function cannot be
+    // called on the browser process UI or IO threads.
+    ///
+    extern(System) int function (cef_waitable_event_t* self, int64 max_ms) nothrow timed_wait;
+}
+
+
+
+///
+// Create a new waitable event. If |automatic_reset| is true (1) then the event
+// state is automatically reset to un-signaled after a single waiting thread has
+// been released; otherwise, the state remains signaled until reset() is called
+// manually. If |initially_signaled| is true (1) then the event will start in
+// the signaled state.
+///
+cef_waitable_event_t* cef_waitable_event_create (
+    int automatic_reset,
+    int initially_signaled);
+
+// CEF_INCLUDE_CAPI_CEF_WAITABLE_EVENT_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=f51ad9ffc67d94b9cbfad154e7f224111c2a96fa$
+//
+
+extern (C):
+
+
+
+///
+// Information about a specific web plugin.
+///
+struct cef_web_plugin_info_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the plugin name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_web_plugin_info_t* self) nothrow get_name;
+
+    ///
+    // Returns the plugin file path (DLL/bundle/library).
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_web_plugin_info_t* self) nothrow get_path;
+
+    ///
+    // Returns the version of the plugin (may be OS-specific).
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_web_plugin_info_t* self) nothrow get_version;
+
+    ///
+    // Returns a description of the plugin from the version information.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_web_plugin_info_t* self) nothrow get_description;
+}
+
+
+
+///
+// Structure to implement for visiting web plugin information. The functions of
+// this structure will be called on the browser process UI thread.
+///
+struct cef_web_plugin_info_visitor_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be called once for each plugin. |count| is the 0-based
+    // index for the current plugin. |total| is the total number of plugins.
+    // Return false (0) to stop visiting plugins. This function may never be
+    // called if no plugins are found.
+    ///
+    extern(System) int function (
+        cef_web_plugin_info_visitor_t* self,
+        cef_web_plugin_info_t* info,
+        int count,
+        int total) nothrow visit;
+}
+
+
+
+///
+// Structure to implement for receiving unstable plugin information. The
+// functions of this structure will be called on the browser process IO thread.
+///
+struct cef_web_plugin_unstable_callback_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Method that will be called for the requested plugin. |unstable| will be
+    // true (1) if the plugin has reached the crash count threshold of 3 times in
+    // 120 seconds.
+    ///
+    extern(System) void function (
+        cef_web_plugin_unstable_callback_t* self,
+        const(cef_string_t)* path,
+        int unstable) nothrow is_unstable;
+}
+
+
+
+///
+// Visit web plugin information. Can be called on any thread in the browser
+// process.
+///
+void cef_visit_web_plugin_info (cef_web_plugin_info_visitor_t* visitor);
+
+///
+// Cause the plugin list to refresh the next time it is accessed regardless of
+// whether it has already been loaded. Can be called on any thread in the
+// browser process.
+///
+void cef_refresh_web_plugins ();
+
+///
+// Unregister an internal plugin. This may be undone the next time
+// cef_refresh_web_plugins() is called. Can be called on any thread in the
+// browser process.
+///
+void cef_unregister_internal_web_plugin (const(cef_string_t)* path);
+
+///
+// Register a plugin crash. Can be called on any thread in the browser process
+// but will be executed on the IO thread.
+///
+void cef_register_web_plugin_crash (const(cef_string_t)* path);
+
+///
+// Query if a plugin is unstable. Can be called on any thread in the browser
+// process.
+///
+void cef_is_web_plugin_unstable (
+    const(cef_string_t)* path,
+    cef_web_plugin_unstable_callback_t* callback);
+
+// CEF_INCLUDE_CAPI_CEF_WEB_PLUGIN_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=e06ad8a1e173edd1e888ce6a8f8a9d95394e6a44$
+//
+
+extern (C):
+
+///
+// Structure representing the issuer or subject field of an X.509 certificate.
+///
+struct cef_x509cert_principal_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns a name that can be used to represent the issuer. It tries in this
+    // order: Common Name (CN), Organization Name (O) and Organizational Unit Name
+    // (OU) and returns the first non-NULL one found.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_x509cert_principal_t* self) nothrow get_display_name;
+
+    ///
+    // Returns the common name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_x509cert_principal_t* self) nothrow get_common_name;
+
+    ///
+    // Returns the locality name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_x509cert_principal_t* self) nothrow get_locality_name;
+
+    ///
+    // Returns the state or province name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_x509cert_principal_t* self) nothrow get_state_or_province_name;
+
+    ///
+    // Returns the country name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_x509cert_principal_t* self) nothrow get_country_name;
+
+    ///
+    // Retrieve the list of street addresses.
+    ///
+    extern(System) void function (
+        cef_x509cert_principal_t* self,
+        cef_string_list_t addresses) nothrow get_street_addresses;
+
+    ///
+    // Retrieve the list of organization names.
+    ///
+    extern(System) void function (
+        cef_x509cert_principal_t* self,
+        cef_string_list_t names) nothrow get_organization_names;
+
+    ///
+    // Retrieve the list of organization unit names.
+    ///
+    extern(System) void function (
+        cef_x509cert_principal_t* self,
+        cef_string_list_t names) nothrow get_organization_unit_names;
+
+    ///
+    // Retrieve the list of domain components.
+    ///
+    extern(System) void function (
+        cef_x509cert_principal_t* self,
+        cef_string_list_t components) nothrow get_domain_components;
+}
+
+
+
+///
+// Structure representing a X.509 certificate.
+///
+struct cef_x509certificate_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Returns the subject of the X.509 certificate. For HTTPS server certificates
+    // this represents the web server.  The common name of the subject should
+    // match the host name of the web server.
+    ///
+    extern(System) cef_x509cert_principal_t* function (
+        cef_x509certificate_t* self) nothrow get_subject;
+
+    ///
+    // Returns the issuer of the X.509 certificate.
+    ///
+    extern(System) cef_x509cert_principal_t* function (
+        cef_x509certificate_t* self) nothrow get_issuer;
+
+    ///
+    // Returns the DER encoded serial number for the X.509 certificate. The value
+    // possibly includes a leading 00 byte.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_x509certificate_t* self) nothrow get_serial_number;
+
+    ///
+    // Returns the date before which the X.509 certificate is invalid.
+    // CefTime.GetTimeT() will return 0 if no date was specified.
+    ///
+    extern(System) cef_time_t function (cef_x509certificate_t* self) nothrow get_valid_start;
+
+    ///
+    // Returns the date after which the X.509 certificate is invalid.
+    // CefTime.GetTimeT() will return 0 if no date was specified.
+    ///
+    extern(System) cef_time_t function (cef_x509certificate_t* self) nothrow get_valid_expiry;
+
+    ///
+    // Returns the DER encoded data for the X.509 certificate.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_x509certificate_t* self) nothrow get_derencoded;
+
+    ///
+    // Returns the PEM encoded data for the X.509 certificate.
+    ///
+    extern(System) cef_binary_value_t* function (
+        cef_x509certificate_t* self) nothrow get_pemencoded;
+
+    ///
+    // Returns the number of certificates in the issuer chain. If 0, the
+    // certificate is self-signed.
+    ///
+    extern(System) size_t function (cef_x509certificate_t* self) nothrow get_issuer_chain_size;
+
+    ///
+    // Returns the DER encoded data for the certificate issuer chain. If we failed
+    // to encode a certificate in the chain it is still present in the array but
+    // is an NULL string.
+    ///
+    extern(System) void function (
+        cef_x509certificate_t* self,
+        size_t* chainCount,
+        cef_binary_value_t** chain) nothrow get_derencoded_issuer_chain;
+
+    ///
+    // Returns the PEM encoded data for the certificate issuer chain. If we failed
+    // to encode a certificate in the chain it is still present in the array but
+    // is an NULL string.
+    ///
+    extern(System) void function (
+        cef_x509certificate_t* self,
+        size_t* chainCount,
+        cef_binary_value_t** chain) nothrow get_pemencoded_issuer_chain;
+}
+
+
+
+// CEF_INCLUDE_CAPI_CEF_X509_CERTIFICATE_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=76de25a0d0f0a2cc4657f46c26ec44b6d7d937e8$
+//
+
+extern (C):
+
+///
+// Structure that supports the reading of XML data via the libxml streaming API.
+// The functions of this structure should only be called on the thread that
+// creates the object.
+///
+struct cef_xml_reader_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Moves the cursor to the next node in the document. This function must be
+    // called at least once to set the current cursor position. Returns true (1)
+    // if the cursor position was set successfully.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow move_to_next_node;
+
+    ///
+    // Close the document. This should be called directly to ensure that cleanup
+    // occurs on the correct thread.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow close;
+
+    ///
+    // Returns true (1) if an error has been reported by the XML parser.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow has_error;
+
+    ///
+    // Returns the error string.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_xml_reader_t* self) nothrow get_error;
+
+    // The below functions retrieve data for the node at the current cursor
+    // position.
+
+    ///
+    // Returns the node type.
+    ///
+    extern(System) cef_xml_node_type_t function (cef_xml_reader_t* self) nothrow get_type;
+
+    ///
+    // Returns the node depth. Depth starts at 0 for the root node.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow get_depth;
+
+    ///
+    // Returns the local name. See http://www.w3.org/TR/REC-xml-names/#NT-
+    // LocalPart for additional details.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_xml_reader_t* self) nothrow get_local_name;
+
+    ///
+    // Returns the namespace prefix. See http://www.w3.org/TR/REC-xml-names/ for
+    // additional details.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_xml_reader_t* self) nothrow get_prefix;
+
+    ///
+    // Returns the qualified name, equal to (Prefix:)LocalName. See
+    // http://www.w3.org/TR/REC-xml-names/#ns-qualnames for additional details.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_xml_reader_t* self) nothrow get_qualified_name;
+
+    ///
+    // Returns the URI defining the namespace associated with the node. See
+    // http://www.w3.org/TR/REC-xml-names/ for additional details.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_xml_reader_t* self) nothrow get_namespace_uri;
+
+    ///
+    // Returns the base URI of the node. See http://www.w3.org/TR/xmlbase/ for
+    // additional details.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_xml_reader_t* self) nothrow get_base_uri;
+
+    ///
+    // Returns the xml:lang scope within which the node resides. See
+    // http://www.w3.org/TR/REC-xml/#sec-lang-tag for additional details.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_xml_reader_t* self) nothrow get_xml_lang;
+
+    ///
+    // Returns true (1) if the node represents an NULL element. <a/> is considered
+    // NULL but <a></a> is not.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow is_empty_element;
+
+    ///
+    // Returns true (1) if the node has a text value.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow has_value;
+
+    ///
+    // Returns the text value.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_xml_reader_t* self) nothrow get_value;
+
+    ///
+    // Returns true (1) if the node has attributes.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow has_attributes;
+
+    ///
+    // Returns the number of attributes.
+    ///
+    extern(System) size_t function (cef_xml_reader_t* self) nothrow get_attribute_count;
+
+    ///
+    // Returns the value of the attribute at the specified 0-based index.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_xml_reader_t* self,
+        int index) nothrow get_attribute_byindex;
+
+    ///
+    // Returns the value of the attribute with the specified qualified name.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_xml_reader_t* self,
+        const(cef_string_t)* qualifiedName) nothrow get_attribute_byqname;
+
+    ///
+    // Returns the value of the attribute with the specified local name and
+    // namespace URI.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (
+        cef_xml_reader_t* self,
+        const(cef_string_t)* localName,
+        const(cef_string_t)* namespaceURI) nothrow get_attribute_bylname;
+
+    ///
+    // Returns an XML representation of the current node's children.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_xml_reader_t* self) nothrow get_inner_xml;
+
+    ///
+    // Returns an XML representation of the current node including its children.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_xml_reader_t* self) nothrow get_outer_xml;
+
+    ///
+    // Returns the line number for the current node.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow get_line_number;
+
+    // Attribute nodes are not traversed by default. The below functions can be
+    // used to move the cursor to an attribute node. move_to_carrying_element()
+    // can be called afterwards to return the cursor to the carrying element. The
+    // depth of an attribute node will be 1 + the depth of the carrying element.
+
+    ///
+    // Moves the cursor to the attribute at the specified 0-based index. Returns
+    // true (1) if the cursor position was set successfully.
+    ///
+    extern(System) int function (
+        cef_xml_reader_t* self,
+        int index) nothrow move_to_attribute_byindex;
+
+    ///
+    // Moves the cursor to the attribute with the specified qualified name.
+    // Returns true (1) if the cursor position was set successfully.
+    ///
+    extern(System) int function (
+        cef_xml_reader_t* self,
+        const(cef_string_t)* qualifiedName) nothrow move_to_attribute_byqname;
+
+    ///
+    // Moves the cursor to the attribute with the specified local name and
+    // namespace URI. Returns true (1) if the cursor position was set
+    // successfully.
+    ///
+    extern(System) int function (
+        cef_xml_reader_t* self,
+        const(cef_string_t)* localName,
+        const(cef_string_t)* namespaceURI) nothrow move_to_attribute_bylname;
+
+    ///
+    // Moves the cursor to the first attribute in the current element. Returns
+    // true (1) if the cursor position was set successfully.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow move_to_first_attribute;
+
+    ///
+    // Moves the cursor to the next attribute in the current element. Returns true
+    // (1) if the cursor position was set successfully.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow move_to_next_attribute;
+
+    ///
+    // Moves the cursor back to the carrying element. Returns true (1) if the
+    // cursor position was set successfully.
+    ///
+    extern(System) int function (cef_xml_reader_t* self) nothrow move_to_carrying_element;
+}
+
+
+
+///
+// Create a new cef_xml_reader_t object. The returned object's functions can
+// only be called from the thread that created the object.
+///
+cef_xml_reader_t* cef_xml_reader_create (
+    cef_stream_reader_t* stream,
+    cef_xml_encoding_type_t encodingType,
+    const(cef_string_t)* URI);
+
+// CEF_INCLUDE_CAPI_CEF_XML_READER_CAPI_H_
+// Copyright (c) 2021 Marshall A. Greenblatt. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ---------------------------------------------------------------------------
+//
+// This file was generated by the CEF translator tool and should not edited
+// by hand. See the translator.README.txt file in the tools directory for
+// more information.
+//
+// $hash=d3d4ee91a69edd5f12785871b5c5a55e86c5c675$
+//
+
+extern (C):
+
+///
+// Structure that supports the reading of zip archives via the zlib unzip API.
+// The functions of this structure should only be called on the thread that
+// creates the object.
+///
+struct cef_zip_reader_t
+{
+    ///
+    // Base structure.
+    ///
+    cef_base_ref_counted_t base;
+
+    ///
+    // Moves the cursor to the first file in the archive. Returns true (1) if the
+    // cursor position was set successfully.
+    ///
+    extern(System) int function (cef_zip_reader_t* self) nothrow move_to_first_file;
+
+    ///
+    // Moves the cursor to the next file in the archive. Returns true (1) if the
+    // cursor position was set successfully.
+    ///
+    extern(System) int function (cef_zip_reader_t* self) nothrow move_to_next_file;
+
+    ///
+    // Moves the cursor to the specified file in the archive. If |caseSensitive|
+    // is true (1) then the search will be case sensitive. Returns true (1) if the
+    // cursor position was set successfully.
+    ///
+    extern(System) int function (
+        cef_zip_reader_t* self,
+        const(cef_string_t)* fileName,
+        int caseSensitive) nothrow move_to_file;
+
+    ///
+    // Closes the archive. This should be called directly to ensure that cleanup
+    // occurs on the correct thread.
+    ///
+    extern(System) int function (cef_zip_reader_t* self) nothrow close;
+
+    // The below functions act on the file at the current cursor position.
+
+    ///
+    // Returns the name of the file.
+    ///
+    // The resulting string must be freed by calling cef_string_userfree_free().
+    extern(System) cef_string_userfree_t function (cef_zip_reader_t* self) nothrow get_file_name;
+
+    ///
+    // Returns the uncompressed size of the file.
+    ///
+    extern(System) int64 function (cef_zip_reader_t* self) nothrow get_file_size;
+
+    ///
+    // Returns the last modified timestamp for the file.
+    ///
+    extern(System) cef_time_t function (cef_zip_reader_t* self) nothrow get_file_last_modified;
+
+    ///
+    // Opens the file for reading of uncompressed data. A read password may
+    // optionally be specified.
+    ///
+    extern(System) int function (
+        cef_zip_reader_t* self,
+        const(cef_string_t)* password) nothrow open_file;
+
+    ///
+    // Closes the file.
+    ///
+    extern(System) int function (cef_zip_reader_t* self) nothrow close_file;
+
+    ///
+    // Read uncompressed file contents into the specified buffer. Returns < 0 if
+    // an error occurred, 0 if at the end of file, or the number of bytes read.
+    ///
+    extern(System) int function (
+        cef_zip_reader_t* self,
+        void* buffer,
+        size_t bufferSize) nothrow read_file;
+
+    ///
+    // Returns the current offset in the uncompressed file contents.
+    ///
+    extern(System) int64 function (cef_zip_reader_t* self) nothrow tell;
+
+    ///
+    // Returns true (1) if at end of the file contents.
+    ///
+    extern(System) int function (cef_zip_reader_t* self) nothrow eof;
+}
+
+
+
+///
+// Create a new cef_zip_reader_t object. The returned object's functions can
+// only be called from the thread that created the object.
+///
+cef_zip_reader_t* cef_zip_reader_create (cef_stream_reader_t* stream);
+
+// CEF_INCLUDE_CAPI_CEF_ZIP_READER_CAPI_H_
+}
+
+}
+
+
+version(Windows) {
+
 /* ************************************ */
 
 // File generated by idl2d from
@@ -19147,8 +19700,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //    interface.
 
 /+[uuid(26d34152-879f-4065-bea2-3daa2cfadfb8), version(1.0)]+/
-version(all)
-{ /+ library WebView2 +/
+/+ library WebView2 +/
 
 // Interface forward declarations
 /+ interface ICoreWebView2AcceleratorKeyPressedEventArgs; +/