using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Security;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.Web.WebView2.Core.Raw;
using Microsoft.Win32.SafeHandles;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: InternalsVisibleTo("Microsoft.Web.WebView2.WinForms, PublicKey=00240000048000009400000006020000002400005253413100040000010001005dba207a79aa19b084a6b574c6f8945bd211921eaefa27a8031dd74b31af8094b3945f00288bc93f0751ecc62d3f5ca42681f09ed4ff1716aefc600bee20b042828dd897db022a07459a20a1042d0fcdd4a19610e838f5cfd992bcad1499861e24a28e5884452ce638803b5fac55a9967d92794723d2f4a0b49cc1148ae03dc7")]
[assembly: InternalsVisibleTo("Microsoft.Web.WebView2.Wpf, PublicKey=00240000048000009400000006020000002400005253413100040000010001005dba207a79aa19b084a6b574c6f8945bd211921eaefa27a8031dd74b31af8094b3945f00288bc93f0751ecc62d3f5ca42681f09ed4ff1716aefc600bee20b042828dd897db022a07459a20a1042d0fcdd4a19610e838f5cfd992bcad1499861e24a28e5884452ce638803b5fac55a9967d92794723d2f4a0b49cc1148ae03dc7")]
[assembly: AssemblyCompany("Microsoft")]
[assembly: AssemblyConfiguration("Release")]
[assembly: Debuggable(false, false)]
[assembly: AssemblyCopyright("Copyright ©2020")]
[assembly: AssemblyProduct("WebView2 .NET Interop Wrapper")]
[assembly: AssemblyTitle("Microsoft.Web.WebView2.Core")]
[assembly: InternalsVisibleTo("dotNetAPIWrapperGeneratorTester, PublicKey=00240000048000009400000006020000002400005253413100040000010001005dba207a79aa19b084a6b574c6f8945bd211921eaefa27a8031dd74b31af8094b3945f00288bc93f0751ecc62d3f5ca42681f09ed4ff1716aefc600bee20b042828dd897db022a07459a20a1042d0fcdd4a19610e838f5cfd992bcad1499861e24a28e5884452ce638803b5fac55a9967d92794723d2f4a0b49cc1148ae03dc7")]
[assembly: AssemblyFileVersion("1.0.4258.31")]
[assembly: AssemblyVersion("1.0.4258.31")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Microsoft.Web.WebView2.Core
{
	internal static class COMDotNetTypeConverter
	{
		public static IReadOnlyList<string> stringCollectionCOMToNet(ICoreWebView2StringCollection rawCollection)
		{
			if (rawCollection == null)
			{
				return null;
			}
			List<string> list = new List<string>(Convert.ToInt32(rawCollection.Count));
			for (uint num = 0u; num < rawCollection.Count; num++)
			{
				list.Add(rawCollection.GetValueAtIndex(num));
			}
			return new ReadOnlyCollection<string>(list);
		}

		public static IReadOnlyList<CoreWebView2ClientCertificate> CoreWebView2ClientCertificateCollectionCOMToNet(ICoreWebView2ClientCertificateCollection rawCollection)
		{
			if (rawCollection == null)
			{
				return null;
			}
			List<CoreWebView2ClientCertificate> list = new List<CoreWebView2ClientCertificate>(Convert.ToInt32(rawCollection.Count));
			for (uint num = 0u; num < rawCollection.Count; num++)
			{
				list.Add(new CoreWebView2ClientCertificate(rawCollection.GetValueAtIndex(num)));
			}
			return new ReadOnlyCollection<CoreWebView2ClientCertificate>(list);
		}

		public static IReadOnlyList<Rectangle> RectangleCollectionCOMToNet(ICoreWebView2RegionRectCollectionView rawCollection)
		{
			if (rawCollection == null)
			{
				return null;
			}
			List<Rectangle> list = new List<Rectangle>(Convert.ToInt32(rawCollection.Count));
			for (uint num = 0u; num < rawCollection.Count; num++)
			{
				list.Add(RectangleCOMToNet(rawCollection.GetValueAtIndex(num)));
			}
			return new ReadOnlyCollection<Rectangle>(list);
		}

		public static IReadOnlyList<CoreWebView2ProcessExtendedInfo> CoreWebView2ProcessExtendedInfoCollectionCOMToNet(ICoreWebView2ProcessExtendedInfoCollection rawCollection)
		{
			if (rawCollection == null)
			{
				return null;
			}
			List<CoreWebView2ProcessExtendedInfo> list = new List<CoreWebView2ProcessExtendedInfo>(Convert.ToInt32(rawCollection.Count));
			for (uint num = 0u; num < rawCollection.Count; num++)
			{
				list.Add(new CoreWebView2ProcessExtendedInfo(rawCollection.GetValueAtIndex(num)));
			}
			return new ReadOnlyCollection<CoreWebView2ProcessExtendedInfo>(list);
		}

		public static IReadOnlyList<CoreWebView2ProcessInfo> CoreWebView2ProcessInfoCollectionCOMToNet(ICoreWebView2ProcessInfoCollection rawCollection)
		{
			if (rawCollection == null)
			{
				return null;
			}
			List<CoreWebView2ProcessInfo> list = new List<CoreWebView2ProcessInfo>(Convert.ToInt32(rawCollection.Count));
			for (uint num = 0u; num < rawCollection.Count; num++)
			{
				list.Add(new CoreWebView2ProcessInfo(rawCollection.GetValueAtIndex(num)));
			}
			return new ReadOnlyCollection<CoreWebView2ProcessInfo>(list);
		}

		public static IReadOnlyList<CoreWebView2BrowserExtension> CoreWebView2BrowserExtensionCollectionCOMToNet(ICoreWebView2BrowserExtensionList rawCollection)
		{
			if (rawCollection == null)
			{
				return null;
			}
			List<CoreWebView2BrowserExtension> list = new List<CoreWebView2BrowserExtension>(Convert.ToInt32(rawCollection.Count));
			for (uint num = 0u; num < rawCollection.Count; num++)
			{
				list.Add(new CoreWebView2BrowserExtension(rawCollection.GetValueAtIndex(num)));
			}
			return new ReadOnlyCollection<CoreWebView2BrowserExtension>(list);
		}

		public static IReadOnlyList<CoreWebView2ServiceWorkerRegistration> CoreWebView2ServiceWorkerRegistrationCollectionCOMToNet(ICoreWebView2ServiceWorkerRegistrationCollectionView rawCollection)
		{
			if (rawCollection == null)
			{
				return null;
			}
			List<CoreWebView2ServiceWorkerRegistration> list = new List<CoreWebView2ServiceWorkerRegistration>(Convert.ToInt32(rawCollection.Count));
			for (uint num = 0u; num < rawCollection.Count; num++)
			{
				list.Add(new CoreWebView2ServiceWorkerRegistration(rawCollection.GetValueAtIndex(num)));
			}
			return new ReadOnlyCollection<CoreWebView2ServiceWorkerRegistration>(list);
		}

		public static IReadOnlyList<CoreWebView2SharedWorker> CoreWebView2SharedWorkerCollectionCOMToNet(ICoreWebView2SharedWorkerCollectionView rawCollection)
		{
			if (rawCollection == null)
			{
				return null;
			}
			List<CoreWebView2SharedWorker> list = new List<CoreWebView2SharedWorker>(Convert.ToInt32(rawCollection.Count));
			for (uint num = 0u; num < rawCollection.Count; num++)
			{
				list.Add(new CoreWebView2SharedWorker(rawCollection.GetValueAtIndex(num)));
			}
			return new ReadOnlyCollection<CoreWebView2SharedWorker>(list);
		}

		public static Rectangle RectangleCOMToNet(tagRECT rect)
		{
			int x = rect.left;
			int y = rect.top;
			int width = rect.right - rect.left;
			int height = rect.bottom - rect.top;
			return new Rectangle(x, y, width, height);
		}

		public static tagRECT RectangleNetToCOM(Rectangle dotNetRect)
		{
			return new tagRECT
			{
				top = dotNetRect.Top,
				left = dotNetRect.Left,
				right = dotNetRect.Right,
				bottom = dotNetRect.Bottom
			};
		}

		public static List<CoreWebView2Cookie> CoreWebView2CookieCollectionCOMToNet(ICoreWebView2CookieList rawCookieList)
		{
			List<CoreWebView2Cookie> list = new List<CoreWebView2Cookie>(Convert.ToInt32(rawCookieList.Count));
			for (uint num = 0u; num < rawCookieList.Count; num++)
			{
				list.Add(new CoreWebView2Cookie(rawCookieList.GetValueAtIndex(num)));
			}
			return list;
		}

		public static IReadOnlyList<CoreWebView2FrameInfo> CoreWebView2FrameInfoCollectionCOMToNet(ICoreWebView2FrameInfoCollection rawFrameInfoCollection)
		{
			if (rawFrameInfoCollection == null)
			{
				return null;
			}
			List<CoreWebView2FrameInfo> list = new List<CoreWebView2FrameInfo>();
			ICoreWebView2FrameInfoCollectionIterator iterator = rawFrameInfoCollection.GetIterator();
			while (iterator.HasCurrent != 0)
			{
				list.Add(new CoreWebView2FrameInfo(iterator.GetCurrent()));
				iterator.MoveNext();
			}
			return new ReadOnlyCollection<CoreWebView2FrameInfo>(list);
		}

		public static Color ColorCOMToNet(COREWEBVIEW2_COLOR color)
		{
			return Color.FromArgb(color.A, color.R, color.G, color.B);
		}

		public static COREWEBVIEW2_COLOR ColorNetToCOM(Color dotNetColor)
		{
			return new COREWEBVIEW2_COLOR
			{
				A = dotNetColor.A,
				R = dotNetColor.R,
				G = dotNetColor.G,
				B = dotNetColor.B
			};
		}

		public static Point PointCOMToNet(tagPOINT point)
		{
			return new Point(point.x, point.y);
		}

		public static tagPOINT PointNetToCOM(Point dotNetPoint)
		{
			return new tagPOINT
			{
				x = Convert.ToInt32(dotNetPoint.X),
				y = Convert.ToInt32(dotNetPoint.Y)
			};
		}

		public static TimeSpan ThrottlingIntervalCOMToNet(int intervalMs)
		{
			return new TimeSpan(0, 0, 0, 0, intervalMs);
		}

		public static int ThrottlingIntervalNetToCOM(TimeSpan timeSpan)
		{
			return timeSpan.Milliseconds;
		}

		public static IReadOnlyList<string> CoreWebView2StringCollectionCOMToNet(ICoreWebView2StringCollection rawStringCollection)
		{
			if (rawStringCollection == null)
			{
				return null;
			}
			List<string> list = new List<string>(Convert.ToInt32(rawStringCollection.Count));
			for (uint num = 0u; num < rawStringCollection.Count; num++)
			{
				list.Add(rawStringCollection.GetValueAtIndex(num));
			}
			return new ReadOnlyCollection<string>(list);
		}

		public static IReadOnlyList<object> objectCollectionCOMToNet(ICoreWebView2ObjectCollectionView rawObjectCollection)
		{
			if (rawObjectCollection == null)
			{
				return null;
			}
			List<object> list = new List<object>(Convert.ToInt32(rawObjectCollection.Count));
			for (uint num = 0u; num < rawObjectCollection.Count; num++)
			{
				object obj = rawObjectCollection.GetValueAtIndex(num);
				if (obj != null)
				{
					if (!(obj is ICoreWebView2File rawCoreWebView2File))
					{
						continue;
					}
					obj = new CoreWebView2File(rawCoreWebView2File);
				}
				list.Add(obj);
			}
			return new ReadOnlyCollection<object>(list);
		}

		public static IList<CoreWebView2ContextMenuItem> CoreWebView2ContextMenuItemCollectionCOMToNet(ICoreWebView2ContextMenuItemCollection rawContextMenuCollection)
		{
			if (rawContextMenuCollection == null)
			{
				return null;
			}
			List<CoreWebView2ContextMenuItem> list = new List<CoreWebView2ContextMenuItem>(Convert.ToInt32(rawContextMenuCollection.Count));
			for (uint num = 0u; num < rawContextMenuCollection.Count; num++)
			{
				list.Add(new CoreWebView2ContextMenuItem(rawContextMenuCollection.GetValueAtIndex(num)));
			}
			ObservableCollection<CoreWebView2ContextMenuItem> collection = new ObservableCollection<CoreWebView2ContextMenuItem>(list);
			collection.CollectionChanged += delegate(object sender, NotifyCollectionChangedEventArgs args)
			{
				switch (args.Action)
				{
				case NotifyCollectionChangedAction.Remove:
					rawContextMenuCollection.RemoveValueAtIndex((uint)args.OldStartingIndex);
					break;
				case NotifyCollectionChangedAction.Add:
					rawContextMenuCollection.InsertValueAtIndex((uint)args.NewStartingIndex, ((CoreWebView2ContextMenuItem)args.NewItems[0])._nativeICoreWebView2ContextMenuItem);
					break;
				case NotifyCollectionChangedAction.Replace:
					rawContextMenuCollection.RemoveValueAtIndex((uint)args.OldStartingIndex);
					rawContextMenuCollection.InsertValueAtIndex((uint)args.NewStartingIndex, ((CoreWebView2ContextMenuItem)args.NewItems[0])._nativeICoreWebView2ContextMenuItem);
					break;
				case NotifyCollectionChangedAction.Move:
				case NotifyCollectionChangedAction.Reset:
				{
					uint count = rawContextMenuCollection.Count;
					for (uint num2 = 0u; num2 < count; num2++)
					{
						rawContextMenuCollection.RemoveValueAtIndex(0u);
					}
					for (int i = 0; i < collection.Count; i++)
					{
						rawContextMenuCollection.InsertValueAtIndex((uint)i, collection[i]._nativeICoreWebView2ContextMenuItem);
					}
					break;
				}
				}
			};
			return collection;
		}

		public static IReadOnlyList<Rectangle> CoreWebView2RegionRectCollectionViewCOMToNet(ICoreWebView2RegionRectCollectionView regionList)
		{
			if (regionList == null)
			{
				return null;
			}
			List<Rectangle> list = new List<Rectangle>(Convert.ToInt32(regionList.Count));
			for (uint num = 0u; num < regionList.Count; num++)
			{
				list.Add(RectangleCOMToNet(regionList.GetValueAtIndex(num)));
			}
			return new ReadOnlyCollection<Rectangle>(list);
		}

		public static COMStreamWrapper StreamCOMToNet(IStream stream)
		{
			if (stream == null)
			{
				return null;
			}
			return new COMStreamWrapper(stream);
		}

		public static IReadOnlyList<CoreWebView2PermissionSetting> CoreWebView2PermissionSettingCollectionCOMToNet(ICoreWebView2PermissionSettingCollectionView rawPermissionSettingCollectionView)
		{
			if (rawPermissionSettingCollectionView == null)
			{
				return null;
			}
			List<CoreWebView2PermissionSetting> list = new List<CoreWebView2PermissionSetting>(Convert.ToInt32(rawPermissionSettingCollectionView.Count));
			for (uint num = 0u; num < rawPermissionSettingCollectionView.Count; num++)
			{
				list.Add(new CoreWebView2PermissionSetting(rawPermissionSettingCollectionView.GetValueAtIndex(num)));
			}
			return new ReadOnlyCollection<CoreWebView2PermissionSetting>(list);
		}

		public static ICoreWebView2ObjectCollectionView CoreWebView2WebObjectCollectionViewNetToCOM(List<object> dotNetObjectCollection)
		{
			return new CoreWebView2WebObjectCollectionView(dotNetObjectCollection);
		}
	}
	public enum CoreWebView2BoundsMode
	{
		UseRawPixels,
		UseRasterizationScale
	}
	public enum CoreWebView2BrowserProcessExitKind
	{
		Normal,
		Failed
	}
	[Flags]
	public enum CoreWebView2BrowsingDataKinds
	{
		FileSystems = 1,
		IndexedDb = 2,
		LocalStorage = 4,
		WebSql = 8,
		CacheStorage = 0x10,
		AllDomStorage = 0x20,
		Cookies = 0x40,
		AllSite = 0x80,
		DiskCache = 0x100,
		DownloadHistory = 0x200,
		GeneralAutofill = 0x400,
		PasswordAutosave = 0x800,
		BrowsingHistory = 0x1000,
		Settings = 0x2000,
		AllProfile = 0x4000,
		ServiceWorkers = 0x8000
	}
	public enum CoreWebView2CapturePreviewImageFormat
	{
		Png,
		Jpeg
	}
	public enum CoreWebView2ChannelSearchKind
	{
		MostStable,
		LeastStable
	}
	public enum CoreWebView2ClientCertificateKind
	{
		SmartCard,
		Pin,
		Other
	}
	public enum CoreWebView2ContextMenuItemKind
	{
		Command,
		CheckBox,
		Radio,
		Separator,
		Submenu
	}
	public enum CoreWebView2ContextMenuTargetKind
	{
		Page,
		Image,
		SelectedText,
		Audio,
		Video
	}
	public enum CoreWebView2CookieSameSiteKind
	{
		None,
		Lax,
		Strict
	}
	public enum CoreWebView2DefaultDownloadDialogCornerAlignment
	{
		TopLeft,
		TopRight,
		BottomLeft,
		BottomRight
	}
	public enum CoreWebView2DownloadInterruptReason
	{
		None,
		FileFailed,
		FileAccessDenied,
		FileNoSpace,
		FileNameTooLong,
		FileTooLarge,
		FileMalicious,
		FileTransientError,
		FileBlockedByPolicy,
		FileSecurityCheckFailed,
		FileTooShort,
		FileHashMismatch,
		NetworkFailed,
		NetworkTimeout,
		NetworkDisconnected,
		NetworkServerDown,
		NetworkInvalidRequest,
		ServerFailed,
		ServerNoRange,
		ServerBadContent,
		ServerUnauthorized,
		ServerCertificateProblem,
		ServerForbidden,
		ServerUnexpectedResponse,
		ServerContentLengthMismatch,
		ServerCrossOriginRedirect,
		UserCanceled,
		UserShutdown,
		UserPaused,
		DownloadProcessCrashed
	}
	public enum CoreWebView2DownloadState
	{
		InProgress,
		Interrupted,
		Completed
	}
	public enum CoreWebView2FaviconImageFormat
	{
		Png,
		Jpeg
	}
	public enum CoreWebView2FileSystemHandleKind
	{
		File,
		Directory
	}
	public enum CoreWebView2FileSystemHandlePermission
	{
		ReadOnly,
		ReadWrite
	}
	public enum CoreWebView2FrameKind
	{
		Unknown,
		MainFrame,
		Iframe,
		Embed,
		Object
	}
	public enum CoreWebView2HostResourceAccessKind
	{
		Deny,
		Allow,
		DenyCors
	}
	public enum CoreWebView2KeyEventKind
	{
		KeyDown,
		KeyUp,
		SystemKeyDown,
		SystemKeyUp
	}
	public enum CoreWebView2MemoryUsageTargetLevel
	{
		Normal,
		Low
	}
	public enum CoreWebView2MouseEventKind
	{
		HorizontalWheel = 526,
		LeftButtonDoubleClick = 515,
		LeftButtonDown = 513,
		LeftButtonUp = 514,
		Leave = 675,
		MiddleButtonDoubleClick = 521,
		MiddleButtonDown = 519,
		MiddleButtonUp = 520,
		Move = 512,
		RightButtonDoubleClick = 518,
		RightButtonDown = 516,
		RightButtonUp = 517,
		Wheel = 522,
		XButtonDoubleClick = 525,
		XButtonDown = 523,
		XButtonUp = 524,
		NonClientRightButtonDown = 164,
		NonClientRightButtonUp = 165
	}
	[Flags]
	public enum CoreWebView2MouseEventVirtualKeys
	{
		None = 0,
		LeftButton = 1,
		RightButton = 2,
		Shift = 4,
		Control = 8,
		MiddleButton = 0x10,
		XButton1 = 0x20,
		XButton2 = 0x40
	}
	public enum CoreWebView2MoveFocusReason
	{
		Programmatic,
		Next,
		Previous
	}
	public enum CoreWebView2NavigationKind
	{
		Reload,
		BackOrForward,
		NewDocument
	}
	public enum CoreWebView2NonClientRegionKind
	{
		Nowhere = 0,
		Client = 1,
		Caption = 2,
		Minimize = 8,
		Maximize = 9,
		Close = 20
	}
	[Flags]
	public enum CoreWebView2PdfToolbarItems
	{
		None = 0,
		Save = 1,
		Print = 2,
		SaveAs = 4,
		ZoomIn = 8,
		ZoomOut = 0x10,
		Rotate = 0x20,
		FitPage = 0x40,
		PageLayout = 0x80,
		Bookmarks = 0x100,
		PageSelector = 0x200,
		Search = 0x400,
		FullScreen = 0x800,
		MoreSettings = 0x1000
	}
	public enum CoreWebView2PermissionKind
	{
		UnknownPermission,
		Microphone,
		Camera,
		Geolocation,
		Notifications,
		OtherSensors,
		ClipboardRead,
		MultipleAutomaticDownloads,
		FileReadWrite,
		Autoplay,
		LocalFonts,
		MidiSystemExclusiveMessages,
		WindowManagement,
		PersistentStorage
	}
	public enum CoreWebView2PermissionState
	{
		Default,
		Allow,
		Deny
	}
	public enum CoreWebView2PointerEventKind
	{
		Activate = 587,
		Down = 582,
		Enter = 585,
		Leave = 586,
		Up = 583,
		Update = 581
	}
	public enum CoreWebView2PreferredColorScheme
	{
		Auto,
		Light,
		Dark
	}
	public enum CoreWebView2PrintCollation
	{
		Default,
		Collated,
		Uncollated
	}
	public enum CoreWebView2PrintColorMode
	{
		Default,
		Color,
		Grayscale
	}
	public enum CoreWebView2PrintDialogKind
	{
		Browser,
		System
	}
	public enum CoreWebView2PrintDuplex
	{
		Default,
		OneSided,
		TwoSidedLongEdge,
		TwoSidedShortEdge
	}
	public enum CoreWebView2PrintMediaSize
	{
		Default,
		Custom
	}
	public enum CoreWebView2PrintOrientation
	{
		Portrait,
		Landscape
	}
	public enum CoreWebView2PrintStatus
	{
		Succeeded,
		PrinterUnavailable,
		OtherError
	}
	public enum CoreWebView2ProcessFailedKind
	{
		BrowserProcessExited,
		RenderProcessExited,
		RenderProcessUnresponsive,
		FrameRenderProcessExited,
		UtilityProcessExited,
		SandboxHelperProcessExited,
		GpuProcessExited,
		PpapiPluginProcessExited,
		PpapiBrokerProcessExited,
		UnknownProcessExited
	}
	public enum CoreWebView2ProcessFailedReason
	{
		Unexpected,
		Unresponsive,
		Terminated,
		Crashed,
		LaunchFailed,
		OutOfMemory,
		ProfileDeleted,
		NormalExit,
		AbnormalExit,
		IntegrityFailure
	}
	public enum CoreWebView2ProcessKind
	{
		Browser,
		Renderer,
		Utility,
		SandboxHelper,
		Gpu,
		PpapiPlugin,
		PpapiBroker
	}
	[Flags]
	public enum CoreWebView2ReleaseChannels
	{
		None = 0,
		Stable = 1,
		Beta = 2,
		Dev = 4,
		Canary = 8
	}
	public enum CoreWebView2SaveAsKind
	{
		Default,
		HtmlOnly,
		SingleFile,
		Complete
	}
	public enum CoreWebView2SaveAsUIResult
	{
		Success,
		InvalidPath,
		FileAlreadyExists,
		KindNotSupported,
		Cancelled
	}
	public enum CoreWebView2ScriptDialogKind
	{
		Alert,
		Confirm,
		Prompt,
		Beforeunload
	}
	public enum CoreWebView2ScrollbarStyle
	{
		Default,
		FluentOverlay
	}
	public enum CoreWebView2ServerCertificateErrorAction
	{
		AlwaysAllow,
		Cancel,
		Default
	}
	public enum CoreWebView2SharedBufferAccess
	{
		ReadOnly,
		ReadWrite
	}
	public enum CoreWebView2TextDirectionKind
	{
		Default,
		LeftToRight,
		RightToLeft
	}
	public enum CoreWebView2TrackingPreventionLevel
	{
		None,
		Basic,
		Balanced,
		Strict
	}
	public enum CoreWebView2WebErrorStatus
	{
		Unknown,
		CertificateCommonNameIsIncorrect,
		CertificateExpired,
		ClientCertificateContainsErrors,
		CertificateRevoked,
		CertificateIsInvalid,
		ServerUnreachable,
		Timeout,
		ErrorHttpInvalidServerResponse,
		ConnectionAborted,
		ConnectionReset,
		Disconnected,
		CannotConnect,
		HostNameNotResolved,
		OperationCanceled,
		RedirectFailed,
		UnexpectedError,
		ValidAuthenticationCredentialsRequired,
		ValidProxyAuthenticationRequired
	}
	public enum CoreWebView2WebResourceContext
	{
		All,
		Document,
		Stylesheet,
		Image,
		Media,
		Font,
		Script,
		XmlHttpRequest,
		Fetch,
		TextTrack,
		EventSource,
		Websocket,
		Manifest,
		SignedExchange,
		Ping,
		CspViolationReport,
		Other
	}
	[Flags]
	public enum CoreWebView2WebResourceRequestSourceKinds
	{
		None = 0,
		Document = 1,
		SharedWorker = 2,
		ServiceWorker = 4,
		All = -1
	}
	public struct CoreWebView2Color
	{
		public byte A;

		public byte R;

		public byte G;

		public byte B;

		internal CoreWebView2Color(COREWEBVIEW2_COLOR rawStruct)
		{
			A = rawStruct.A;
			R = rawStruct.R;
			G = rawStruct.G;
			B = rawStruct.B;
		}
	}
	public class CoreWebView2
	{
		internal object _rawNative;

		internal ICoreWebView2 _nativeICoreWebView2Value;

		private EventRegistrationToken _ContainsFullScreenElementChangedToken;

		private EventHandler<object> privateContainsFullScreenElementChanged;

		private EventRegistrationToken _ContentLoadingToken;

		private EventHandler<CoreWebView2ContentLoadingEventArgs> privateContentLoading;

		private EventRegistrationToken _DocumentTitleChangedToken;

		private EventHandler<object> privateDocumentTitleChanged;

		private EventRegistrationToken _FrameNavigationCompletedToken;

		private EventHandler<CoreWebView2NavigationCompletedEventArgs> privateFrameNavigationCompleted;

		private EventRegistrationToken _FrameNavigationStartingToken;

		private EventHandler<CoreWebView2NavigationStartingEventArgs> privateFrameNavigationStarting;

		private EventRegistrationToken _HistoryChangedToken;

		private EventHandler<object> privateHistoryChanged;

		private EventRegistrationToken _NavigationCompletedToken;

		private EventHandler<CoreWebView2NavigationCompletedEventArgs> privateNavigationCompleted;

		private EventRegistrationToken _NavigationStartingToken;

		private EventHandler<CoreWebView2NavigationStartingEventArgs> privateNavigationStarting;

		private EventRegistrationToken _NewWindowRequestedToken;

		private EventHandler<CoreWebView2NewWindowRequestedEventArgs> privateNewWindowRequested;

		private EventRegistrationToken _PermissionRequestedToken;

		private EventHandler<CoreWebView2PermissionRequestedEventArgs> privatePermissionRequested;

		private EventRegistrationToken _ProcessFailedToken;

		private EventHandler<CoreWebView2ProcessFailedEventArgs> privateProcessFailed;

		private EventRegistrationToken _ScriptDialogOpeningToken;

		private EventHandler<CoreWebView2ScriptDialogOpeningEventArgs> privateScriptDialogOpening;

		private EventRegistrationToken _SourceChangedToken;

		private EventHandler<CoreWebView2SourceChangedEventArgs> privateSourceChanged;

		private EventRegistrationToken _WebMessageReceivedToken;

		private EventHandler<CoreWebView2WebMessageReceivedEventArgs> privateWebMessageReceived;

		private EventRegistrationToken _WebResourceRequestedToken;

		private EventHandler<CoreWebView2WebResourceRequestedEventArgs> privateWebResourceRequested;

		private EventRegistrationToken _WindowCloseRequestedToken;

		private EventHandler<object> privateWindowCloseRequested;

		internal ICoreWebView2PrivatePartial _nativeICoreWebView2PrivatePartialValue;

		internal ICoreWebView2_10 _nativeICoreWebView2_10Value;

		private EventRegistrationToken _BasicAuthenticationRequestedToken;

		private EventHandler<CoreWebView2BasicAuthenticationRequestedEventArgs> privateBasicAuthenticationRequested;

		internal ICoreWebView2_11 _nativeICoreWebView2_11Value;

		private EventRegistrationToken _ContextMenuRequestedToken;

		private EventHandler<CoreWebView2ContextMenuRequestedEventArgs> privateContextMenuRequested;

		internal ICoreWebView2_12 _nativeICoreWebView2_12Value;

		private EventRegistrationToken _StatusBarTextChangedToken;

		private EventHandler<object> privateStatusBarTextChanged;

		internal ICoreWebView2_13 _nativeICoreWebView2_13Value;

		internal ICoreWebView2_14 _nativeICoreWebView2_14Value;

		private EventRegistrationToken _ServerCertificateErrorDetectedToken;

		private EventHandler<CoreWebView2ServerCertificateErrorDetectedEventArgs> privateServerCertificateErrorDetected;

		internal ICoreWebView2_15 _nativeICoreWebView2_15Value;

		private EventRegistrationToken _FaviconChangedToken;

		private EventHandler<object> privateFaviconChanged;

		internal ICoreWebView2_16 _nativeICoreWebView2_16Value;

		internal ICoreWebView2_17 _nativeICoreWebView2_17Value;

		internal ICoreWebView2_18 _nativeICoreWebView2_18Value;

		private EventRegistrationToken _LaunchingExternalUriSchemeToken;

		private EventHandler<CoreWebView2LaunchingExternalUriSchemeEventArgs> privateLaunchingExternalUriScheme;

		internal ICoreWebView2_19 _nativeICoreWebView2_19Value;

		internal ICoreWebView2_2 _nativeICoreWebView2_2Value;

		private EventRegistrationToken _DOMContentLoadedToken;

		private EventHandler<CoreWebView2DOMContentLoadedEventArgs> privateDOMContentLoaded;

		private EventRegistrationToken _WebResourceResponseReceivedToken;

		private EventHandler<CoreWebView2WebResourceResponseReceivedEventArgs> privateWebResourceResponseReceived;

		internal ICoreWebView2_20 _nativeICoreWebView2_20Value;

		internal ICoreWebView2_21 _nativeICoreWebView2_21Value;

		internal ICoreWebView2_22 _nativeICoreWebView2_22Value;

		internal ICoreWebView2_25 _nativeICoreWebView2_25Value;

		private EventRegistrationToken _SaveAsUIShowingToken;

		private EventHandler<CoreWebView2SaveAsUIShowingEventArgs> privateSaveAsUIShowing;

		internal ICoreWebView2_23 _nativeICoreWebView2_23Value;

		internal ICoreWebView2_27 _nativeICoreWebView2_27Value;

		private EventRegistrationToken _ScreenCaptureStartingToken;

		private EventHandler<CoreWebView2ScreenCaptureStartingEventArgs> privateScreenCaptureStarting;

		internal ICoreWebView2_28 _nativeICoreWebView2_28Value;

		internal ICoreWebView2_26 _nativeICoreWebView2_26Value;

		private EventRegistrationToken _SaveFileSecurityCheckStartingToken;

		private EventHandler<CoreWebView2SaveFileSecurityCheckStartingEventArgs> privateSaveFileSecurityCheckStarting;

		internal ICoreWebView2_24 _nativeICoreWebView2_24Value;

		private EventRegistrationToken _NotificationReceivedToken;

		private EventHandler<CoreWebView2NotificationReceivedEventArgs> privateNotificationReceived;

		internal ICoreWebView2_3 _nativeICoreWebView2_3Value;

		internal ICoreWebView2_29 _nativeICoreWebView2_29Value;

		private EventRegistrationToken _DedicatedWorkerCreatedToken;

		private EventHandler<CoreWebView2DedicatedWorkerCreatedEventArgs> privateDedicatedWorkerCreated;

		internal ICoreWebView2_4 _nativeICoreWebView2_4Value;

		private EventRegistrationToken _DownloadStartingToken;

		private EventHandler<CoreWebView2DownloadStartingEventArgs> privateDownloadStarting;

		private EventRegistrationToken _FrameCreatedToken;

		private EventHandler<CoreWebView2FrameCreatedEventArgs> privateFrameCreated;

		internal ICoreWebView2_5 _nativeICoreWebView2_5Value;

		private EventRegistrationToken _ClientCertificateRequestedToken;

		private EventHandler<CoreWebView2ClientCertificateRequestedEventArgs> privateClientCertificateRequested;

		internal ICoreWebView2_6 _nativeICoreWebView2_6Value;

		internal ICoreWebView2_7 _nativeICoreWebView2_7Value;

		internal ICoreWebView2_8 _nativeICoreWebView2_8Value;

		private EventRegistrationToken _IsDocumentPlayingAudioChangedToken;

		private EventHandler<object> privateIsDocumentPlayingAudioChanged;

		private EventRegistrationToken _IsMutedChangedToken;

		private EventHandler<object> privateIsMutedChanged;

		internal ICoreWebView2_9 _nativeICoreWebView2_9Value;

		private EventRegistrationToken _IsDefaultDownloadDialogOpenChangedToken;

		private EventHandler<object> privateIsDefaultDownloadDialogOpenChanged;

		internal ICoreWebView2 _nativeICoreWebView2
		{
			get
			{
				if (_nativeICoreWebView2Value == null)
				{
					try
					{
						_nativeICoreWebView2Value = (ICoreWebView2)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2Value;
			}
			set
			{
				_nativeICoreWebView2Value = value;
			}
		}

		public uint BrowserProcessId
		{
			get
			{
				try
				{
					return _nativeICoreWebView2.BrowserProcessId;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public bool CanGoBack
		{
			get
			{
				try
				{
					return _nativeICoreWebView2.CanGoBack != 0;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public bool CanGoForward
		{
			get
			{
				try
				{
					return _nativeICoreWebView2.CanGoForward != 0;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public bool ContainsFullScreenElement
		{
			get
			{
				try
				{
					return _nativeICoreWebView2.ContainsFullScreenElement != 0;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public string DocumentTitle
		{
			get
			{
				try
				{
					return _nativeICoreWebView2.DocumentTitle;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public CoreWebView2Settings Settings
		{
			get
			{
				try
				{
					return (_nativeICoreWebView2.Settings == null) ? null : new CoreWebView2Settings(_nativeICoreWebView2.Settings);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public string Source
		{
			get
			{
				try
				{
					return _nativeICoreWebView2.Source;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2PrivatePartial _nativeICoreWebView2PrivatePartial
		{
			get
			{
				if (_nativeICoreWebView2PrivatePartialValue == null)
				{
					try
					{
						_nativeICoreWebView2PrivatePartialValue = (ICoreWebView2PrivatePartial)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2PrivatePartial.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2PrivatePartialValue;
			}
			set
			{
				_nativeICoreWebView2PrivatePartialValue = value;
			}
		}

		internal ICoreWebView2_10 _nativeICoreWebView2_10
		{
			get
			{
				if (_nativeICoreWebView2_10Value == null)
				{
					try
					{
						_nativeICoreWebView2_10Value = (ICoreWebView2_10)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_10.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_10Value;
			}
			set
			{
				_nativeICoreWebView2_10Value = value;
			}
		}

		internal ICoreWebView2_11 _nativeICoreWebView2_11
		{
			get
			{
				if (_nativeICoreWebView2_11Value == null)
				{
					try
					{
						_nativeICoreWebView2_11Value = (ICoreWebView2_11)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_11.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_11Value;
			}
			set
			{
				_nativeICoreWebView2_11Value = value;
			}
		}

		internal ICoreWebView2_12 _nativeICoreWebView2_12
		{
			get
			{
				if (_nativeICoreWebView2_12Value == null)
				{
					try
					{
						_nativeICoreWebView2_12Value = (ICoreWebView2_12)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_12.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_12Value;
			}
			set
			{
				_nativeICoreWebView2_12Value = value;
			}
		}

		public string StatusBarText
		{
			get
			{
				try
				{
					return _nativeICoreWebView2_12.StatusBarText;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2_13 _nativeICoreWebView2_13
		{
			get
			{
				if (_nativeICoreWebView2_13Value == null)
				{
					try
					{
						_nativeICoreWebView2_13Value = (ICoreWebView2_13)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_13.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_13Value;
			}
			set
			{
				_nativeICoreWebView2_13Value = value;
			}
		}

		public CoreWebView2Profile Profile
		{
			get
			{
				try
				{
					return (_nativeICoreWebView2_13.Profile == null) ? null : new CoreWebView2Profile(_nativeICoreWebView2_13.Profile);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2_14 _nativeICoreWebView2_14
		{
			get
			{
				if (_nativeICoreWebView2_14Value == null)
				{
					try
					{
						_nativeICoreWebView2_14Value = (ICoreWebView2_14)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_14.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_14Value;
			}
			set
			{
				_nativeICoreWebView2_14Value = value;
			}
		}

		internal ICoreWebView2_15 _nativeICoreWebView2_15
		{
			get
			{
				if (_nativeICoreWebView2_15Value == null)
				{
					try
					{
						_nativeICoreWebView2_15Value = (ICoreWebView2_15)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_15.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_15Value;
			}
			set
			{
				_nativeICoreWebView2_15Value = value;
			}
		}

		public string FaviconUri
		{
			get
			{
				try
				{
					return _nativeICoreWebView2_15.FaviconUri;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2_16 _nativeICoreWebView2_16
		{
			get
			{
				if (_nativeICoreWebView2_16Value == null)
				{
					try
					{
						_nativeICoreWebView2_16Value = (ICoreWebView2_16)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_16.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_16Value;
			}
			set
			{
				_nativeICoreWebView2_16Value = value;
			}
		}

		internal ICoreWebView2_17 _nativeICoreWebView2_17
		{
			get
			{
				if (_nativeICoreWebView2_17Value == null)
				{
					try
					{
						_nativeICoreWebView2_17Value = (ICoreWebView2_17)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_17.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_17Value;
			}
			set
			{
				_nativeICoreWebView2_17Value = value;
			}
		}

		internal ICoreWebView2_18 _nativeICoreWebView2_18
		{
			get
			{
				if (_nativeICoreWebView2_18Value == null)
				{
					try
					{
						_nativeICoreWebView2_18Value = (ICoreWebView2_18)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_18.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_18Value;
			}
			set
			{
				_nativeICoreWebView2_18Value = value;
			}
		}

		internal ICoreWebView2_19 _nativeICoreWebView2_19
		{
			get
			{
				if (_nativeICoreWebView2_19Value == null)
				{
					try
					{
						_nativeICoreWebView2_19Value = (ICoreWebView2_19)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_19.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_19Value;
			}
			set
			{
				_nativeICoreWebView2_19Value = value;
			}
		}

		public CoreWebView2MemoryUsageTargetLevel MemoryUsageTargetLevel
		{
			get
			{
				try
				{
					return (CoreWebView2MemoryUsageTargetLevel)_nativeICoreWebView2_19.MemoryUsageTargetLevel;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
			set
			{
				try
				{
					_nativeICoreWebView2_19.MemoryUsageTargetLevel = (COREWEBVIEW2_MEMORY_USAGE_TARGET_LEVEL)value;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2_2 _nativeICoreWebView2_2
		{
			get
			{
				if (_nativeICoreWebView2_2Value == null)
				{
					try
					{
						_nativeICoreWebView2_2Value = (ICoreWebView2_2)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_2.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_2Value;
			}
			set
			{
				_nativeICoreWebView2_2Value = value;
			}
		}

		public CoreWebView2CookieManager CookieManager
		{
			get
			{
				try
				{
					return (_nativeICoreWebView2_2.CookieManager == null) ? null : new CoreWebView2CookieManager(_nativeICoreWebView2_2.CookieManager);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public CoreWebView2Environment Environment
		{
			get
			{
				try
				{
					return (_nativeICoreWebView2_2.Environment == null) ? null : new CoreWebView2Environment(_nativeICoreWebView2_2.Environment);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2_20 _nativeICoreWebView2_20
		{
			get
			{
				if (_nativeICoreWebView2_20Value == null)
				{
					try
					{
						_nativeICoreWebView2_20Value = (ICoreWebView2_20)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_20.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_20Value;
			}
			set
			{
				_nativeICoreWebView2_20Value = value;
			}
		}

		public uint FrameId
		{
			get
			{
				try
				{
					return _nativeICoreWebView2_20.FrameId;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2_21 _nativeICoreWebView2_21
		{
			get
			{
				if (_nativeICoreWebView2_21Value == null)
				{
					try
					{
						_nativeICoreWebView2_21Value = (ICoreWebView2_21)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_21.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_21Value;
			}
			set
			{
				_nativeICoreWebView2_21Value = value;
			}
		}

		internal ICoreWebView2_22 _nativeICoreWebView2_22
		{
			get
			{
				if (_nativeICoreWebView2_22Value == null)
				{
					try
					{
						_nativeICoreWebView2_22Value = (ICoreWebView2_22)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_22.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_22Value;
			}
			set
			{
				_nativeICoreWebView2_22Value = value;
			}
		}

		internal ICoreWebView2_25 _nativeICoreWebView2_25
		{
			get
			{
				if (_nativeICoreWebView2_25Value == null)
				{
					try
					{
						_nativeICoreWebView2_25Value = (ICoreWebView2_25)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_25.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_25Value;
			}
			set
			{
				_nativeICoreWebView2_25Value = value;
			}
		}

		internal ICoreWebView2_23 _nativeICoreWebView2_23
		{
			get
			{
				if (_nativeICoreWebView2_23Value == null)
				{
					try
					{
						_nativeICoreWebView2_23Value = (ICoreWebView2_23)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_23.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_23Value;
			}
			set
			{
				_nativeICoreWebView2_23Value = value;
			}
		}

		internal ICoreWebView2_27 _nativeICoreWebView2_27
		{
			get
			{
				if (_nativeICoreWebView2_27Value == null)
				{
					try
					{
						_nativeICoreWebView2_27Value = (ICoreWebView2_27)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_27.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_27Value;
			}
			set
			{
				_nativeICoreWebView2_27Value = value;
			}
		}

		internal ICoreWebView2_28 _nativeICoreWebView2_28
		{
			get
			{
				if (_nativeICoreWebView2_28Value == null)
				{
					try
					{
						_nativeICoreWebView2_28Value = (ICoreWebView2_28)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_28.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_28Value;
			}
			set
			{
				_nativeICoreWebView2_28Value = value;
			}
		}

		public CoreWebView2Find Find
		{
			get
			{
				try
				{
					return (_nativeICoreWebView2_28.Find == null) ? null : new CoreWebView2Find(_nativeICoreWebView2_28.Find);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2_26 _nativeICoreWebView2_26
		{
			get
			{
				if (_nativeICoreWebView2_26Value == null)
				{
					try
					{
						_nativeICoreWebView2_26Value = (ICoreWebView2_26)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_26.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_26Value;
			}
			set
			{
				_nativeICoreWebView2_26Value = value;
			}
		}

		internal ICoreWebView2_24 _nativeICoreWebView2_24
		{
			get
			{
				if (_nativeICoreWebView2_24Value == null)
				{
					try
					{
						_nativeICoreWebView2_24Value = (ICoreWebView2_24)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_24.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_24Value;
			}
			set
			{
				_nativeICoreWebView2_24Value = value;
			}
		}

		internal ICoreWebView2_3 _nativeICoreWebView2_3
		{
			get
			{
				if (_nativeICoreWebView2_3Value == null)
				{
					try
					{
						_nativeICoreWebView2_3Value = (ICoreWebView2_3)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_3.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_3Value;
			}
			set
			{
				_nativeICoreWebView2_3Value = value;
			}
		}

		public bool IsSuspended
		{
			get
			{
				try
				{
					return _nativeICoreWebView2_3.IsSuspended != 0;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2_29 _nativeICoreWebView2_29
		{
			get
			{
				if (_nativeICoreWebView2_29Value == null)
				{
					try
					{
						_nativeICoreWebView2_29Value = (ICoreWebView2_29)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_29.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_29Value;
			}
			set
			{
				_nativeICoreWebView2_29Value = value;
			}
		}

		internal ICoreWebView2_4 _nativeICoreWebView2_4
		{
			get
			{
				if (_nativeICoreWebView2_4Value == null)
				{
					try
					{
						_nativeICoreWebView2_4Value = (ICoreWebView2_4)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_4.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_4Value;
			}
			set
			{
				_nativeICoreWebView2_4Value = value;
			}
		}

		internal ICoreWebView2_5 _nativeICoreWebView2_5
		{
			get
			{
				if (_nativeICoreWebView2_5Value == null)
				{
					try
					{
						_nativeICoreWebView2_5Value = (ICoreWebView2_5)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_5.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_5Value;
			}
			set
			{
				_nativeICoreWebView2_5Value = value;
			}
		}

		internal ICoreWebView2_6 _nativeICoreWebView2_6
		{
			get
			{
				if (_nativeICoreWebView2_6Value == null)
				{
					try
					{
						_nativeICoreWebView2_6Value = (ICoreWebView2_6)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_6.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_6Value;
			}
			set
			{
				_nativeICoreWebView2_6Value = value;
			}
		}

		internal ICoreWebView2_7 _nativeICoreWebView2_7
		{
			get
			{
				if (_nativeICoreWebView2_7Value == null)
				{
					try
					{
						_nativeICoreWebView2_7Value = (ICoreWebView2_7)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_7.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_7Value;
			}
			set
			{
				_nativeICoreWebView2_7Value = value;
			}
		}

		internal ICoreWebView2_8 _nativeICoreWebView2_8
		{
			get
			{
				if (_nativeICoreWebView2_8Value == null)
				{
					try
					{
						_nativeICoreWebView2_8Value = (ICoreWebView2_8)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_8.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_8Value;
			}
			set
			{
				_nativeICoreWebView2_8Value = value;
			}
		}

		public bool IsDocumentPlayingAudio
		{
			get
			{
				try
				{
					return _nativeICoreWebView2_8.IsDocumentPlayingAudio != 0;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public bool IsMuted
		{
			get
			{
				try
				{
					return _nativeICoreWebView2_8.IsMuted != 0;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
			set
			{
				try
				{
					_nativeICoreWebView2_8.IsMuted = (value ? 1 : 0);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		internal ICoreWebView2_9 _nativeICoreWebView2_9
		{
			get
			{
				if (_nativeICoreWebView2_9Value == null)
				{
					try
					{
						_nativeICoreWebView2_9Value = (ICoreWebView2_9)_rawNative;
					}
					catch (Exception inner)
					{
						throw new NotImplementedException("Unable to cast to Microsoft.Web.WebView2.Core.Raw.ICoreWebView2_9.\nThis may happen if you are using an interface not supported by the version of the WebView2 Runtime you are using.\nFor instance, if you are using an experimental interface from an older SDK that has been modified or removed in a newer runtime.\nOr, if you are using a public interface from a newer SDK that wasn't implemented in an older runtime.\nFor more information about WebView2 versioning please visit the following: https://learn.microsoft.com/microsoft-edge/webview2/concepts/versioning", inner);
					}
				}
				return _nativeICoreWebView2_9Value;
			}
			set
			{
				_nativeICoreWebView2_9Value = value;
			}
		}

		public CoreWebView2DefaultDownloadDialogCornerAlignment DefaultDownloadDialogCornerAlignment
		{
			get
			{
				try
				{
					return (CoreWebView2DefaultDownloadDialogCornerAlignment)_nativeICoreWebView2_9.DefaultDownloadDialogCornerAlignment;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
			set
			{
				try
				{
					_nativeICoreWebView2_9.DefaultDownloadDialogCornerAlignment = (COREWEBVIEW2_DEFAULT_DOWNLOAD_DIALOG_CORNER_ALIGNMENT)value;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public Point DefaultDownloadDialogMargin
		{
			get
			{
				try
				{
					return COMDotNetTypeConverter.PointCOMToNet(_nativeICoreWebView2_9.DefaultDownloadDialogMargin);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
			set
			{
				try
				{
					_nativeICoreWebView2_9.DefaultDownloadDialogMargin = COMDotNetTypeConverter.PointNetToCOM(value);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public bool IsDefaultDownloadDialogOpen
		{
			get
			{
				try
				{
					return _nativeICoreWebView2_9.IsDefaultDownloadDialogOpen != 0;
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<object> ContainsFullScreenElementChanged
		{
			add
			{
				if (privateContainsFullScreenElementChanged == null)
				{
					try
					{
						_nativeICoreWebView2.add_ContainsFullScreenElementChanged(new CoreWebView2ContainsFullScreenElementChangedEventHandler(OnContainsFullScreenElementChanged), out _ContainsFullScreenElementChangedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateContainsFullScreenElementChanged = (EventHandler<object>)Delegate.Combine(privateContainsFullScreenElementChanged, value);
			}
			remove
			{
				privateContainsFullScreenElementChanged = (EventHandler<object>)Delegate.Remove(privateContainsFullScreenElementChanged, value);
				if (privateContainsFullScreenElementChanged != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_ContainsFullScreenElementChanged(_ContainsFullScreenElementChangedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2ContentLoadingEventArgs> ContentLoading
		{
			add
			{
				if (privateContentLoading == null)
				{
					try
					{
						_nativeICoreWebView2.add_ContentLoading(new CoreWebView2ContentLoadingEventHandler(OnContentLoading), out _ContentLoadingToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateContentLoading = (EventHandler<CoreWebView2ContentLoadingEventArgs>)Delegate.Combine(privateContentLoading, value);
			}
			remove
			{
				privateContentLoading = (EventHandler<CoreWebView2ContentLoadingEventArgs>)Delegate.Remove(privateContentLoading, value);
				if (privateContentLoading != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_ContentLoading(_ContentLoadingToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<object> DocumentTitleChanged
		{
			add
			{
				if (privateDocumentTitleChanged == null)
				{
					try
					{
						_nativeICoreWebView2.add_DocumentTitleChanged(new CoreWebView2DocumentTitleChangedEventHandler(OnDocumentTitleChanged), out _DocumentTitleChangedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateDocumentTitleChanged = (EventHandler<object>)Delegate.Combine(privateDocumentTitleChanged, value);
			}
			remove
			{
				privateDocumentTitleChanged = (EventHandler<object>)Delegate.Remove(privateDocumentTitleChanged, value);
				if (privateDocumentTitleChanged != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_DocumentTitleChanged(_DocumentTitleChangedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2NavigationCompletedEventArgs> FrameNavigationCompleted
		{
			add
			{
				if (privateFrameNavigationCompleted == null)
				{
					try
					{
						_nativeICoreWebView2.add_FrameNavigationCompleted(new CoreWebView2NavigationCompletedEventHandler(OnFrameNavigationCompleted), out _FrameNavigationCompletedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateFrameNavigationCompleted = (EventHandler<CoreWebView2NavigationCompletedEventArgs>)Delegate.Combine(privateFrameNavigationCompleted, value);
			}
			remove
			{
				privateFrameNavigationCompleted = (EventHandler<CoreWebView2NavigationCompletedEventArgs>)Delegate.Remove(privateFrameNavigationCompleted, value);
				if (privateFrameNavigationCompleted != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_FrameNavigationCompleted(_FrameNavigationCompletedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2NavigationStartingEventArgs> FrameNavigationStarting
		{
			add
			{
				if (privateFrameNavigationStarting == null)
				{
					try
					{
						_nativeICoreWebView2.add_FrameNavigationStarting(new CoreWebView2NavigationStartingEventHandler(OnFrameNavigationStarting), out _FrameNavigationStartingToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateFrameNavigationStarting = (EventHandler<CoreWebView2NavigationStartingEventArgs>)Delegate.Combine(privateFrameNavigationStarting, value);
			}
			remove
			{
				privateFrameNavigationStarting = (EventHandler<CoreWebView2NavigationStartingEventArgs>)Delegate.Remove(privateFrameNavigationStarting, value);
				if (privateFrameNavigationStarting != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_FrameNavigationStarting(_FrameNavigationStartingToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<object> HistoryChanged
		{
			add
			{
				if (privateHistoryChanged == null)
				{
					try
					{
						_nativeICoreWebView2.add_HistoryChanged(new CoreWebView2HistoryChangedEventHandler(OnHistoryChanged), out _HistoryChangedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateHistoryChanged = (EventHandler<object>)Delegate.Combine(privateHistoryChanged, value);
			}
			remove
			{
				privateHistoryChanged = (EventHandler<object>)Delegate.Remove(privateHistoryChanged, value);
				if (privateHistoryChanged != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_HistoryChanged(_HistoryChangedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2NavigationCompletedEventArgs> NavigationCompleted
		{
			add
			{
				if (privateNavigationCompleted == null)
				{
					try
					{
						_nativeICoreWebView2.add_NavigationCompleted(new CoreWebView2NavigationCompletedEventHandler(OnNavigationCompleted), out _NavigationCompletedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateNavigationCompleted = (EventHandler<CoreWebView2NavigationCompletedEventArgs>)Delegate.Combine(privateNavigationCompleted, value);
			}
			remove
			{
				privateNavigationCompleted = (EventHandler<CoreWebView2NavigationCompletedEventArgs>)Delegate.Remove(privateNavigationCompleted, value);
				if (privateNavigationCompleted != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_NavigationCompleted(_NavigationCompletedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2NavigationStartingEventArgs> NavigationStarting
		{
			add
			{
				if (privateNavigationStarting == null)
				{
					try
					{
						_nativeICoreWebView2.add_NavigationStarting(new CoreWebView2NavigationStartingEventHandler(OnNavigationStarting), out _NavigationStartingToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateNavigationStarting = (EventHandler<CoreWebView2NavigationStartingEventArgs>)Delegate.Combine(privateNavigationStarting, value);
			}
			remove
			{
				privateNavigationStarting = (EventHandler<CoreWebView2NavigationStartingEventArgs>)Delegate.Remove(privateNavigationStarting, value);
				if (privateNavigationStarting != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_NavigationStarting(_NavigationStartingToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2NewWindowRequestedEventArgs> NewWindowRequested
		{
			add
			{
				if (privateNewWindowRequested == null)
				{
					try
					{
						_nativeICoreWebView2.add_NewWindowRequested(new CoreWebView2NewWindowRequestedEventHandler(OnNewWindowRequested), out _NewWindowRequestedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateNewWindowRequested = (EventHandler<CoreWebView2NewWindowRequestedEventArgs>)Delegate.Combine(privateNewWindowRequested, value);
			}
			remove
			{
				privateNewWindowRequested = (EventHandler<CoreWebView2NewWindowRequestedEventArgs>)Delegate.Remove(privateNewWindowRequested, value);
				if (privateNewWindowRequested != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_NewWindowRequested(_NewWindowRequestedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2PermissionRequestedEventArgs> PermissionRequested
		{
			add
			{
				if (privatePermissionRequested == null)
				{
					try
					{
						_nativeICoreWebView2.add_PermissionRequested(new CoreWebView2PermissionRequestedEventHandler(OnPermissionRequested), out _PermissionRequestedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privatePermissionRequested = (EventHandler<CoreWebView2PermissionRequestedEventArgs>)Delegate.Combine(privatePermissionRequested, value);
			}
			remove
			{
				privatePermissionRequested = (EventHandler<CoreWebView2PermissionRequestedEventArgs>)Delegate.Remove(privatePermissionRequested, value);
				if (privatePermissionRequested != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_PermissionRequested(_PermissionRequestedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2ProcessFailedEventArgs> ProcessFailed
		{
			add
			{
				if (privateProcessFailed == null)
				{
					try
					{
						_nativeICoreWebView2.add_ProcessFailed(new CoreWebView2ProcessFailedEventHandler(OnProcessFailed), out _ProcessFailedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateProcessFailed = (EventHandler<CoreWebView2ProcessFailedEventArgs>)Delegate.Combine(privateProcessFailed, value);
			}
			remove
			{
				privateProcessFailed = (EventHandler<CoreWebView2ProcessFailedEventArgs>)Delegate.Remove(privateProcessFailed, value);
				if (privateProcessFailed != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_ProcessFailed(_ProcessFailedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2ScriptDialogOpeningEventArgs> ScriptDialogOpening
		{
			add
			{
				if (privateScriptDialogOpening == null)
				{
					try
					{
						_nativeICoreWebView2.add_ScriptDialogOpening(new CoreWebView2ScriptDialogOpeningEventHandler(OnScriptDialogOpening), out _ScriptDialogOpeningToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateScriptDialogOpening = (EventHandler<CoreWebView2ScriptDialogOpeningEventArgs>)Delegate.Combine(privateScriptDialogOpening, value);
			}
			remove
			{
				privateScriptDialogOpening = (EventHandler<CoreWebView2ScriptDialogOpeningEventArgs>)Delegate.Remove(privateScriptDialogOpening, value);
				if (privateScriptDialogOpening != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_ScriptDialogOpening(_ScriptDialogOpeningToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2SourceChangedEventArgs> SourceChanged
		{
			add
			{
				if (privateSourceChanged == null)
				{
					try
					{
						_nativeICoreWebView2.add_SourceChanged(new CoreWebView2SourceChangedEventHandler(OnSourceChanged), out _SourceChangedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateSourceChanged = (EventHandler<CoreWebView2SourceChangedEventArgs>)Delegate.Combine(privateSourceChanged, value);
			}
			remove
			{
				privateSourceChanged = (EventHandler<CoreWebView2SourceChangedEventArgs>)Delegate.Remove(privateSourceChanged, value);
				if (privateSourceChanged != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_SourceChanged(_SourceChangedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2WebMessageReceivedEventArgs> WebMessageReceived
		{
			add
			{
				if (privateWebMessageReceived == null)
				{
					try
					{
						_nativeICoreWebView2.add_WebMessageReceived(new CoreWebView2WebMessageReceivedEventHandler(OnWebMessageReceived), out _WebMessageReceivedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateWebMessageReceived = (EventHandler<CoreWebView2WebMessageReceivedEventArgs>)Delegate.Combine(privateWebMessageReceived, value);
			}
			remove
			{
				privateWebMessageReceived = (EventHandler<CoreWebView2WebMessageReceivedEventArgs>)Delegate.Remove(privateWebMessageReceived, value);
				if (privateWebMessageReceived != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_WebMessageReceived(_WebMessageReceivedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2WebResourceRequestedEventArgs> WebResourceRequested
		{
			add
			{
				if (privateWebResourceRequested == null)
				{
					try
					{
						_nativeICoreWebView2.add_WebResourceRequested(new CoreWebView2WebResourceRequestedEventHandler(OnWebResourceRequested), out _WebResourceRequestedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateWebResourceRequested = (EventHandler<CoreWebView2WebResourceRequestedEventArgs>)Delegate.Combine(privateWebResourceRequested, value);
			}
			remove
			{
				privateWebResourceRequested = (EventHandler<CoreWebView2WebResourceRequestedEventArgs>)Delegate.Remove(privateWebResourceRequested, value);
				if (privateWebResourceRequested != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_WebResourceRequested(_WebResourceRequestedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<object> WindowCloseRequested
		{
			add
			{
				if (privateWindowCloseRequested == null)
				{
					try
					{
						_nativeICoreWebView2.add_WindowCloseRequested(new CoreWebView2WindowCloseRequestedEventHandler(OnWindowCloseRequested), out _WindowCloseRequestedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
						}
						throw ex2;
					}
				}
				privateWindowCloseRequested = (EventHandler<object>)Delegate.Combine(privateWindowCloseRequested, value);
			}
			remove
			{
				privateWindowCloseRequested = (EventHandler<object>)Delegate.Remove(privateWindowCloseRequested, value);
				if (privateWindowCloseRequested != null)
				{
					return;
				}
				try
				{
					_nativeICoreWebView2.remove_WindowCloseRequested(_WindowCloseRequestedToken);
				}
				catch (InvalidCastException ex)
				{
					if (ex.HResult == -2147467262)
					{
						throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
					}
					throw ex;
				}
				catch (COMException ex2)
				{
					if (ex2.HResult == -2147019873)
					{
						throw new InvalidOperationException("CoreWebView2 members cannot be accessed after the WebView2 control is disposed.", ex2);
					}
					throw ex2;
				}
			}
		}

		public event EventHandler<CoreWebView2BasicAuthenticationRequestedEventArgs> BasicAuthenticationRequested
		{
			add
			{
				if (privateBasicAuthenticationRequested == null)
				{
					try
					{
						_nativeICoreWebView2_10.add_BasicAuthenticationRequested(new CoreWebView2BasicAuthenticationRequestedEventHandler(OnBasicAuthenticationRequested), out _BasicAuthenticationRequestedToken);
					}
					catch (InvalidCastException ex)
					{
						if (ex.HResult == -2147467262)
						{
							throw new InvalidOperationException("CoreWebView2 members can only be accessed from the UI thread.", ex);
						}
						throw ex;
					}
					catch (COMException ex2)
					{
						if (ex2.HResult == -2147019873)
						{
							throw n