// ------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------

#pragma warning disable CS1591,CS1573,CS0465,CS0649,CS8019,CS1570,CS1584,CS1658,CS0436,CS8981
using global::System;
using global::System.Diagnostics;
using global::System.Diagnostics.CodeAnalysis;
using global::System.Runtime.CompilerServices;
using global::System.Runtime.InteropServices;
using global::System.Runtime.Versioning;
using winmdroot = global::Windows.Win32;
namespace Windows.Win32
{
	namespace Web.MsHtml
	{
		[Guid("3050F434-98B5-11CF-BB82-00AA00BDCE0B")]
		[global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
		internal unsafe partial struct IHTMLElement2
			:IVTable<IHTMLElement2,IHTMLElement2.Vtbl>,IComIID		{
			/// <inheritdoc cref="QueryInterface(global::System.Guid*, void**)"/>
			internal unsafe winmdroot.Foundation.HRESULT QueryInterface(in global::System.Guid riid, out void* ppvObject)
			{
				fixed (void** ppvObjectLocal = &ppvObject)
				{
					fixed (global::System.Guid* riidLocal = &riid)
					{
						winmdroot.Foundation.HRESULT __result = this.QueryInterface(riidLocal, ppvObjectLocal);
						return __result;
					}
				}
			}

			public unsafe winmdroot.Foundation.HRESULT QueryInterface(global::System.Guid* riid, void** ppvObject)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[0])((IHTMLElement2*)Unsafe.AsPointer(ref this), riid, ppvObject);
			}

			public uint AddRef()
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,uint>)lpVtbl[1])((IHTMLElement2*)Unsafe.AsPointer(ref this));
			}

			public uint Release()
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,uint>)lpVtbl[2])((IHTMLElement2*)Unsafe.AsPointer(ref this));
			}

			/// <inheritdoc cref="GetTypeInfoCount(uint*)"/>
			internal unsafe void GetTypeInfoCount(out uint pctinfo)
			{
				fixed (uint* pctinfoLocal = &pctinfo)
				{
					this.GetTypeInfoCount(pctinfoLocal);
				}
			}

			public unsafe void GetTypeInfoCount(uint* pctinfo)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,uint* ,winmdroot.Foundation.HRESULT>)lpVtbl[3])((IHTMLElement2*)Unsafe.AsPointer(ref this), pctinfo).ThrowOnFailure();
			}

			public unsafe void GetTypeInfo(uint iTInfo, uint lcid, winmdroot.System.Com.ITypeInfo** ppTInfo)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,uint ,uint ,winmdroot.System.Com.ITypeInfo** ,winmdroot.Foundation.HRESULT>)lpVtbl[4])((IHTMLElement2*)Unsafe.AsPointer(ref this), iTInfo, lcid, ppTInfo).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetIDsOfNames(global::System.Guid*, winmdroot.Foundation.PWSTR*, uint, uint, int*)"/>
			internal unsafe void GetIDsOfNames(in global::System.Guid riid, ReadOnlySpan<winmdroot.Foundation.PWSTR> rgszNames, uint lcid, Span<int> rgDispId)
			{
				fixed (int* rgDispIdLocal = rgDispId)
				{
					fixed (winmdroot.Foundation.PWSTR* rgszNamesLocal = rgszNames)
					{
						fixed (global::System.Guid* riidLocal = &riid)
						{
							if (rgszNames.Length != rgDispId.Length)								throw new ArgumentException();
							this.GetIDsOfNames(riidLocal, rgszNamesLocal, (uint )rgDispId.Length, lcid, rgDispIdLocal);
						}
					}
				}
			}

			public unsafe void GetIDsOfNames(global::System.Guid* riid, winmdroot.Foundation.PWSTR* rgszNames, uint cNames, uint lcid, int* rgDispId)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,global::System.Guid* ,winmdroot.Foundation.PWSTR* ,uint ,uint ,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[5])((IHTMLElement2*)Unsafe.AsPointer(ref this), riid, rgszNames, cNames, lcid, rgDispId).ThrowOnFailure();
			}

			/// <inheritdoc cref="Invoke(int, global::System.Guid*, uint, winmdroot.System.Com.DISPATCH_FLAGS, winmdroot.System.Com.DISPPARAMS*, winmdroot.System.Variant.VARIANT*, winmdroot.System.Com.EXCEPINFO*, uint*)"/>
			internal unsafe void Invoke(int dispIdMember, in global::System.Guid riid, uint lcid, winmdroot.System.Com.DISPATCH_FLAGS wFlags, in winmdroot.System.Com.DISPPARAMS pDispParams, winmdroot.System.Variant.VARIANT* pVarResult, winmdroot.System.Com.EXCEPINFO* pExcepInfo, uint* puArgErr)
			{
				fixed (winmdroot.System.Com.DISPPARAMS* pDispParamsLocal = &pDispParams)
				{
					fixed (global::System.Guid* riidLocal = &riid)
					{
						this.Invoke(dispIdMember, riidLocal, lcid, wFlags, pDispParamsLocal, pVarResult, pExcepInfo, puArgErr);
					}
				}
			}

			public unsafe void Invoke(int dispIdMember, global::System.Guid* riid, uint lcid, winmdroot.System.Com.DISPATCH_FLAGS wFlags, winmdroot.System.Com.DISPPARAMS* pDispParams, [Optional] winmdroot.System.Variant.VARIANT* pVarResult, [Optional] winmdroot.System.Com.EXCEPINFO* pExcepInfo, [Optional] uint* puArgErr)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,global::System.Guid* ,uint ,winmdroot.System.Com.DISPATCH_FLAGS ,winmdroot.System.Com.DISPPARAMS* ,winmdroot.System.Variant.VARIANT* ,winmdroot.System.Com.EXCEPINFO* ,uint* ,winmdroot.Foundation.HRESULT>)lpVtbl[6])((IHTMLElement2*)Unsafe.AsPointer(ref this), dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_scopeName(IHTMLElement2* pThis, winmdroot.Foundation.BSTR* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.scopeName;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.Foundation.BSTR scopeName
			{
				get
				{
					winmdroot.Foundation.BSTR __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[7])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT setCapture(IHTMLElement2* pThis, winmdroot.Foundation.VARIANT_BOOL containerCapture)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.setCapture(containerCapture);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public void setCapture(winmdroot.Foundation.VARIANT_BOOL containerCapture)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.VARIANT_BOOL ,winmdroot.Foundation.HRESULT>)lpVtbl[8])((IHTMLElement2*)Unsafe.AsPointer(ref this), containerCapture).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT releaseCapture(IHTMLElement2* pThis)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.releaseCapture();
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public void releaseCapture()
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.HRESULT>)lpVtbl[9])((IHTMLElement2*)Unsafe.AsPointer(ref this)).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onlosecapture(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onlosecapture = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onlosecapture
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[10])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[11])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onlosecapture(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onlosecapture;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT componentFromPoint(IHTMLElement2* pThis, int x, int y, winmdroot.Foundation.BSTR* component)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.componentFromPoint(x, y, component);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.BSTR componentFromPoint(int x, int y)
			{
				winmdroot.Foundation.BSTR __retVal = default(winmdroot.Foundation.BSTR);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,int ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[12])((IHTMLElement2*)Unsafe.AsPointer(ref this), x, y, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT doScroll(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT component)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.doScroll(component);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public void doScroll(winmdroot.System.Variant.VARIANT component)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[13])((IHTMLElement2*)Unsafe.AsPointer(ref this), component).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onscroll(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onscroll = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onscroll
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[14])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[15])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onscroll(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onscroll;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_ondrag(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondrag = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT ondrag
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[16])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[17])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondrag(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondrag;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_ondragend(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondragend = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT ondragend
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[18])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[19])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondragend(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondragend;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_ondragenter(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondragenter = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT ondragenter
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[20])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[21])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondragenter(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondragenter;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_ondragover(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondragover = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT ondragover
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[22])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[23])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondragover(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondragover;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_ondragleave(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondragleave = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT ondragleave
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[24])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[25])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondragleave(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondragleave;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_ondrop(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondrop = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT ondrop
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[26])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[27])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondrop(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondrop;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onbeforecut(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onbeforecut = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onbeforecut
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[28])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[29])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onbeforecut(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onbeforecut;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_oncut(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.oncut = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT oncut
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[30])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[31])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_oncut(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.oncut;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onbeforecopy(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onbeforecopy = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onbeforecopy
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[32])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[33])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onbeforecopy(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onbeforecopy;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_oncopy(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.oncopy = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT oncopy
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[34])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[35])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_oncopy(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.oncopy;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onbeforepaste(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onbeforepaste = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onbeforepaste
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[36])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[37])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onbeforepaste(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onbeforepaste;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onpaste(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onpaste = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onpaste
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[38])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[39])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onpaste(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onpaste;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_currentStyle(IHTMLElement2* pThis, winmdroot.Web.MsHtml.IHTMLCurrentStyle** p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.currentStyle;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal unsafe winmdroot.Web.MsHtml.IHTMLCurrentStyle* currentStyle
			{
				get
				{
					winmdroot.Web.MsHtml.IHTMLCurrentStyle* __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLCurrentStyle** ,winmdroot.Foundation.HRESULT>)lpVtbl[40])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onpropertychange(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onpropertychange = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onpropertychange
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[41])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[42])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onpropertychange(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onpropertychange;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT getClientRects(IHTMLElement2* pThis, winmdroot.Web.MsHtml.IHTMLRectCollection** pRectCol)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.getClientRects(pRectCol);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Web.MsHtml.IHTMLRectCollection* getClientRects()
			{
				winmdroot.Web.MsHtml.IHTMLRectCollection* __retVal = default(winmdroot.Web.MsHtml.IHTMLRectCollection*);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLRectCollection** ,winmdroot.Foundation.HRESULT>)lpVtbl[43])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT getBoundingClientRect(IHTMLElement2* pThis, winmdroot.Web.MsHtml.IHTMLRect** pRect)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.getBoundingClientRect(pRect);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Web.MsHtml.IHTMLRect* getBoundingClientRect()
			{
				winmdroot.Web.MsHtml.IHTMLRect* __retVal = default(winmdroot.Web.MsHtml.IHTMLRect*);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLRect** ,winmdroot.Foundation.HRESULT>)lpVtbl[44])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT setExpression(IHTMLElement2* pThis, winmdroot.Foundation.BSTR propname, winmdroot.Foundation.BSTR expression, winmdroot.Foundation.BSTR language)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.setExpression(propname, expression, language);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public void setExpression(winmdroot.Foundation.BSTR propname, winmdroot.Foundation.BSTR expression, winmdroot.Foundation.BSTR language)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[45])((IHTMLElement2*)Unsafe.AsPointer(ref this), propname, expression, language).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT getExpression(IHTMLElement2* pThis, winmdroot.Foundation.BSTR propname, winmdroot.System.Variant.VARIANT* expression)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.getExpression(propname, expression);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.System.Variant.VARIANT getExpression(winmdroot.Foundation.BSTR propname)
			{
				winmdroot.System.Variant.VARIANT __retVal = default(winmdroot.System.Variant.VARIANT);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[46])((IHTMLElement2*)Unsafe.AsPointer(ref this), propname, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT removeExpression(IHTMLElement2* pThis, winmdroot.Foundation.BSTR propname, winmdroot.Foundation.VARIANT_BOOL* pfSuccess)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.removeExpression(propname, pfSuccess);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.VARIANT_BOOL removeExpression(winmdroot.Foundation.BSTR propname)
			{
				winmdroot.Foundation.VARIANT_BOOL __retVal = default(winmdroot.Foundation.VARIANT_BOOL);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[47])((IHTMLElement2*)Unsafe.AsPointer(ref this), propname, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_tabIndex(IHTMLElement2* pThis, short v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.put_tabIndex(v);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.HRESULT put_tabIndex(short v)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,short ,winmdroot.Foundation.HRESULT>)lpVtbl[48])((IHTMLElement2*)Unsafe.AsPointer(ref this), v);
			}

			/// <inheritdoc cref="get_tabIndex(short*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_tabIndex(out short p)
			{
				fixed (short* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_tabIndex(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_tabIndex(IHTMLElement2* pThis, short* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_tabIndex(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_tabIndex(short* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,short* ,winmdroot.Foundation.HRESULT>)lpVtbl[49])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT focus(IHTMLElement2* pThis)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.focus();
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.HRESULT focus()
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.HRESULT>)lpVtbl[50])((IHTMLElement2*)Unsafe.AsPointer(ref this));
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_accessKey(IHTMLElement2* pThis, winmdroot.Foundation.BSTR v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.accessKey = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.Foundation.BSTR accessKey
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[51])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.Foundation.BSTR __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[52])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_accessKey(IHTMLElement2* pThis, winmdroot.Foundation.BSTR* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.accessKey;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onblur(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onblur = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onblur
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[53])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[54])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onblur(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onblur;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onfocus(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onfocus = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onfocus
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[55])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[56])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onfocus(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onfocus;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onresize(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onresize = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onresize
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[57])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[58])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onresize(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onresize;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT blur(IHTMLElement2* pThis)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.blur();
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.HRESULT blur()
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.HRESULT>)lpVtbl[59])((IHTMLElement2*)Unsafe.AsPointer(ref this));
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT addFilter(IHTMLElement2* pThis, winmdroot.System.Com.IUnknown* pUnk)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.addFilter(pUnk);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe void addFilter(winmdroot.System.Com.IUnknown* pUnk)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Com.IUnknown* ,winmdroot.Foundation.HRESULT>)lpVtbl[60])((IHTMLElement2*)Unsafe.AsPointer(ref this), pUnk).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT removeFilter(IHTMLElement2* pThis, winmdroot.System.Com.IUnknown* pUnk)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.removeFilter(pUnk);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe void removeFilter(winmdroot.System.Com.IUnknown* pUnk)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Com.IUnknown* ,winmdroot.Foundation.HRESULT>)lpVtbl[61])((IHTMLElement2*)Unsafe.AsPointer(ref this), pUnk).ThrowOnFailure();
			}

			/// <inheritdoc cref="get_clientHeight(int*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_clientHeight(out int p)
			{
				fixed (int* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_clientHeight(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_clientHeight(IHTMLElement2* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_clientHeight(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_clientHeight(int* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[62])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			/// <inheritdoc cref="get_clientWidth(int*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_clientWidth(out int p)
			{
				fixed (int* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_clientWidth(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_clientWidth(IHTMLElement2* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_clientWidth(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_clientWidth(int* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[63])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			/// <inheritdoc cref="get_clientTop(int*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_clientTop(out int p)
			{
				fixed (int* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_clientTop(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_clientTop(IHTMLElement2* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_clientTop(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_clientTop(int* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[64])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			/// <inheritdoc cref="get_clientLeft(int*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_clientLeft(out int p)
			{
				fixed (int* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_clientLeft(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_clientLeft(IHTMLElement2* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_clientLeft(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_clientLeft(int* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[65])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			/// <inheritdoc cref="attachEvent(winmdroot.Foundation.BSTR, winmdroot.System.Com.IDispatch*, winmdroot.Foundation.VARIANT_BOOL*)"/>
			internal unsafe winmdroot.Foundation.HRESULT attachEvent(winmdroot.Foundation.BSTR @event, winmdroot.System.Com.IDispatch* pDisp, out winmdroot.Foundation.VARIANT_BOOL pfResult)
			{
				fixed (winmdroot.Foundation.VARIANT_BOOL* pfResultLocal = &pfResult)
				{
					winmdroot.Foundation.HRESULT __result = this.attachEvent(@event, pDisp, pfResultLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT attachEvent(IHTMLElement2* pThis, winmdroot.Foundation.BSTR @event, winmdroot.System.Com.IDispatch* pDisp, winmdroot.Foundation.VARIANT_BOOL* pfResult)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.attachEvent(@event, pDisp, pfResult);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT attachEvent(winmdroot.Foundation.BSTR @event, winmdroot.System.Com.IDispatch* pDisp, winmdroot.Foundation.VARIANT_BOOL* pfResult)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.System.Com.IDispatch* ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[66])((IHTMLElement2*)Unsafe.AsPointer(ref this), @event, pDisp, pfResult);
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT detachEvent(IHTMLElement2* pThis, winmdroot.Foundation.BSTR @event, winmdroot.System.Com.IDispatch* pDisp)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.detachEvent(@event, pDisp);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT detachEvent(winmdroot.Foundation.BSTR @event, winmdroot.System.Com.IDispatch* pDisp)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.System.Com.IDispatch* ,winmdroot.Foundation.HRESULT>)lpVtbl[67])((IHTMLElement2*)Unsafe.AsPointer(ref this), @event, pDisp);
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_readyState(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.readyState;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT readyState
			{
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[68])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onreadystatechange(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onreadystatechange = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onreadystatechange
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[69])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[70])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onreadystatechange(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onreadystatechange;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onrowsdelete(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onrowsdelete = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onrowsdelete
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[71])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[72])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onrowsdelete(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onrowsdelete;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onrowsinserted(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onrowsinserted = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onrowsinserted
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[73])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[74])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onrowsinserted(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onrowsinserted;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_oncellchange(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.oncellchange = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT oncellchange
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[75])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[76])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_oncellchange(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.oncellchange;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_dir(IHTMLElement2* pThis, winmdroot.Foundation.BSTR v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.dir = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.Foundation.BSTR dir
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[77])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.Foundation.BSTR __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[78])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_dir(IHTMLElement2* pThis, winmdroot.Foundation.BSTR* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.dir;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT createControlRange(IHTMLElement2* pThis, winmdroot.System.Com.IDispatch** range)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.createControlRange(range);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.System.Com.IDispatch* createControlRange()
			{
				winmdroot.System.Com.IDispatch* __retVal = default(winmdroot.System.Com.IDispatch*);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT>)lpVtbl[79])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__retVal).ThrowOnFailure();
				return __retVal;
			}

			/// <inheritdoc cref="get_scrollHeight(int*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_scrollHeight(out int p)
			{
				fixed (int* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_scrollHeight(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_scrollHeight(IHTMLElement2* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_scrollHeight(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_scrollHeight(int* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[80])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			/// <inheritdoc cref="get_scrollWidth(int*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_scrollWidth(out int p)
			{
				fixed (int* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_scrollWidth(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_scrollWidth(IHTMLElement2* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_scrollWidth(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_scrollWidth(int* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[81])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_scrollTop(IHTMLElement2* pThis, int v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.put_scrollTop(v);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.HRESULT put_scrollTop(int v)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[82])((IHTMLElement2*)Unsafe.AsPointer(ref this), v);
			}

			/// <inheritdoc cref="get_scrollTop(int*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_scrollTop(out int p)
			{
				fixed (int* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_scrollTop(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_scrollTop(IHTMLElement2* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_scrollTop(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_scrollTop(int* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[83])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_scrollLeft(IHTMLElement2* pThis, int v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.put_scrollLeft(v);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.HRESULT put_scrollLeft(int v)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[84])((IHTMLElement2*)Unsafe.AsPointer(ref this), v);
			}

			/// <inheritdoc cref="get_scrollLeft(int*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_scrollLeft(out int p)
			{
				fixed (int* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_scrollLeft(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_scrollLeft(IHTMLElement2* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_scrollLeft(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_scrollLeft(int* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[85])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT clearAttributes(IHTMLElement2* pThis)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.clearAttributes();
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public void clearAttributes()
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.HRESULT>)lpVtbl[86])((IHTMLElement2*)Unsafe.AsPointer(ref this)).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT mergeAttributes(IHTMLElement2* pThis, winmdroot.Web.MsHtml.IHTMLElement* mergeThis)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.mergeAttributes(mergeThis);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe void mergeAttributes(winmdroot.Web.MsHtml.IHTMLElement* mergeThis)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLElement* ,winmdroot.Foundation.HRESULT>)lpVtbl[87])((IHTMLElement2*)Unsafe.AsPointer(ref this), mergeThis).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_oncontextmenu(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.oncontextmenu = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT oncontextmenu
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[88])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[89])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_oncontextmenu(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.oncontextmenu;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT insertAdjacentElement(IHTMLElement2* pThis, winmdroot.Foundation.BSTR where, winmdroot.Web.MsHtml.IHTMLElement* insertedElement, winmdroot.Web.MsHtml.IHTMLElement** inserted)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.insertAdjacentElement(where, insertedElement, inserted);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT insertAdjacentElement(winmdroot.Foundation.BSTR where, winmdroot.Web.MsHtml.IHTMLElement* insertedElement, winmdroot.Web.MsHtml.IHTMLElement** inserted)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Web.MsHtml.IHTMLElement* ,winmdroot.Web.MsHtml.IHTMLElement** ,winmdroot.Foundation.HRESULT>)lpVtbl[90])((IHTMLElement2*)Unsafe.AsPointer(ref this), where, insertedElement, inserted);
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT applyElement(IHTMLElement2* pThis, winmdroot.Web.MsHtml.IHTMLElement* apply, winmdroot.Foundation.BSTR where, winmdroot.Web.MsHtml.IHTMLElement** applied)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.applyElement(apply, where, applied);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Web.MsHtml.IHTMLElement* applyElement(winmdroot.Web.MsHtml.IHTMLElement* apply, winmdroot.Foundation.BSTR where)
			{
				winmdroot.Web.MsHtml.IHTMLElement* __retVal = default(winmdroot.Web.MsHtml.IHTMLElement*);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLElement* ,winmdroot.Foundation.BSTR ,winmdroot.Web.MsHtml.IHTMLElement** ,winmdroot.Foundation.HRESULT>)lpVtbl[91])((IHTMLElement2*)Unsafe.AsPointer(ref this), apply, where, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT getAdjacentText(IHTMLElement2* pThis, winmdroot.Foundation.BSTR where, winmdroot.Foundation.BSTR* text)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.getAdjacentText(where, text);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.BSTR getAdjacentText(winmdroot.Foundation.BSTR where)
			{
				winmdroot.Foundation.BSTR __retVal = default(winmdroot.Foundation.BSTR);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[92])((IHTMLElement2*)Unsafe.AsPointer(ref this), where, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT replaceAdjacentText(IHTMLElement2* pThis, winmdroot.Foundation.BSTR where, winmdroot.Foundation.BSTR newText, winmdroot.Foundation.BSTR* oldText)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.replaceAdjacentText(where, newText, oldText);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.BSTR replaceAdjacentText(winmdroot.Foundation.BSTR where, winmdroot.Foundation.BSTR newText)
			{
				winmdroot.Foundation.BSTR __retVal = default(winmdroot.Foundation.BSTR);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[93])((IHTMLElement2*)Unsafe.AsPointer(ref this), where, newText, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			/// <inheritdoc cref="get_canHaveChildren(winmdroot.Foundation.VARIANT_BOOL*)"/>
			internal unsafe winmdroot.Foundation.HRESULT get_canHaveChildren(out winmdroot.Foundation.VARIANT_BOOL p)
			{
				fixed (winmdroot.Foundation.VARIANT_BOOL* pLocal = &p)
				{
					winmdroot.Foundation.HRESULT __result = this.get_canHaveChildren(pLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_canHaveChildren(IHTMLElement2* pThis, winmdroot.Foundation.VARIANT_BOOL* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_canHaveChildren(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_canHaveChildren(winmdroot.Foundation.VARIANT_BOOL* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[94])((IHTMLElement2*)Unsafe.AsPointer(ref this), p);
			}

			/// <inheritdoc cref="addBehavior(winmdroot.Foundation.BSTR, winmdroot.System.Variant.VARIANT*)"/>
			internal unsafe int addBehavior(winmdroot.Foundation.BSTR bstrUrl, in winmdroot.System.Variant.VARIANT pvarFactory)
			{
				fixed (winmdroot.System.Variant.VARIANT* pvarFactoryLocal = &pvarFactory)
				{
					int __result = this.addBehavior(bstrUrl, pvarFactoryLocal);
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT addBehavior(IHTMLElement2* pThis, winmdroot.Foundation.BSTR bstrUrl, winmdroot.System.Variant.VARIANT* pvarFactory, int* pCookie)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.addBehavior(bstrUrl, pvarFactory, pCookie);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe int addBehavior(winmdroot.Foundation.BSTR bstrUrl, winmdroot.System.Variant.VARIANT* pvarFactory)
			{
				int __retVal = default(int);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.System.Variant.VARIANT* ,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[95])((IHTMLElement2*)Unsafe.AsPointer(ref this), bstrUrl, pvarFactory, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT removeBehavior(IHTMLElement2* pThis, int cookie, winmdroot.Foundation.VARIANT_BOOL* pfResult)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.removeBehavior(cookie, pfResult);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.VARIANT_BOOL removeBehavior(int cookie)
			{
				winmdroot.Foundation.VARIANT_BOOL __retVal = default(winmdroot.Foundation.VARIANT_BOOL);
				((delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[96])((IHTMLElement2*)Unsafe.AsPointer(ref this), cookie, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_runtimeStyle(IHTMLElement2* pThis, winmdroot.Web.MsHtml.IHTMLStyle** p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.runtimeStyle;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal unsafe winmdroot.Web.MsHtml.IHTMLStyle* runtimeStyle
			{
				get
				{
					winmdroot.Web.MsHtml.IHTMLStyle* __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLStyle** ,winmdroot.Foundation.HRESULT>)lpVtbl[97])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_behaviorUrns(IHTMLElement2* pThis, winmdroot.System.Com.IDispatch** p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.behaviorUrns;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal unsafe winmdroot.System.Com.IDispatch* behaviorUrns
			{
				get
				{
					winmdroot.System.Com.IDispatch* __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT>)lpVtbl[98])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_tagUrn(IHTMLElement2* pThis, winmdroot.Foundation.BSTR v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.tagUrn = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.Foundation.BSTR tagUrn
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[99])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.Foundation.BSTR __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[100])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_tagUrn(IHTMLElement2* pThis, winmdroot.Foundation.BSTR* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.tagUrn;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT put_onbeforeeditfocus(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onbeforeeditfocus = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.System.Variant.VARIANT onbeforeeditfocus
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[101])((IHTMLElement2*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.System.Variant.VARIANT __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[102])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onbeforeeditfocus(IHTMLElement2* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onbeforeeditfocus;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_readyStateValue(IHTMLElement2* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.readyStateValue;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal int readyStateValue
			{
				get
				{
					int __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[103])((IHTMLElement2*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT getElementsByTagName(IHTMLElement2* pThis, winmdroot.Foundation.BSTR v, winmdroot.Web.MsHtml.IHTMLElementCollection** pelColl)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.getElementsByTagName(v, pelColl);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT getElementsByTagName(winmdroot.Foundation.BSTR v, winmdroot.Web.MsHtml.IHTMLElementCollection** pelColl)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Web.MsHtml.IHTMLElementCollection** ,winmdroot.Foundation.HRESULT>)lpVtbl[104])((IHTMLElement2*)Unsafe.AsPointer(ref this), v, pelColl);
			}

			internal unsafe global::Windows.Win32.Foundation.HRESULT QueryInterface<T>(out T* ppv)
where T : unmanaged

			{
				var hr = this.QueryInterface(typeof(T).GUID, out void* pv);
				if (hr.Succeeded)

				{
					ppv = (T*)pv;
				}
				else

				{
					ppv = null;
				}

				return hr;
			}

			internal struct Vtbl
			{
				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> QueryInterface_1;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,uint> AddRef_2;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,uint> Release_3;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,uint* ,winmdroot.Foundation.HRESULT> GetTypeInfoCount_4;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,uint ,uint ,winmdroot.System.Com.ITypeInfo** ,winmdroot.Foundation.HRESULT> GetTypeInfo_5;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,global::System.Guid* ,winmdroot.Foundation.PWSTR* ,uint ,uint ,int* ,winmdroot.Foundation.HRESULT> GetIDsOfNames_6;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,global::System.Guid* ,uint ,winmdroot.System.Com.DISPATCH_FLAGS ,winmdroot.System.Com.DISPPARAMS* ,winmdroot.System.Variant.VARIANT* ,winmdroot.System.Com.EXCEPINFO* ,uint* ,winmdroot.Foundation.HRESULT> Invoke_7;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_scopeName_8;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.VARIANT_BOOL ,winmdroot.Foundation.HRESULT> setCapture_9;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.HRESULT> releaseCapture_10;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onlosecapture_11;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onlosecapture_12;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,int ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> componentFromPoint_13;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> doScroll_14;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onscroll_15;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onscroll_16;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_ondrag_17;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_ondrag_18;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_ondragend_19;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_ondragend_20;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_ondragenter_21;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_ondragenter_22;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_ondragover_23;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_ondragover_24;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_ondragleave_25;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_ondragleave_26;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_ondrop_27;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_ondrop_28;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onbeforecut_29;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onbeforecut_30;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_oncut_31;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_oncut_32;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onbeforecopy_33;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onbeforecopy_34;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_oncopy_35;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_oncopy_36;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onbeforepaste_37;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onbeforepaste_38;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onpaste_39;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onpaste_40;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLCurrentStyle** ,winmdroot.Foundation.HRESULT> get_currentStyle_41;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onpropertychange_42;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onpropertychange_43;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLRectCollection** ,winmdroot.Foundation.HRESULT> getClientRects_44;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLRect** ,winmdroot.Foundation.HRESULT> getBoundingClientRect_45;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT> setExpression_46;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> getExpression_47;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT> removeExpression_48;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,short ,winmdroot.Foundation.HRESULT> put_tabIndex_49;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,short* ,winmdroot.Foundation.HRESULT> get_tabIndex_50;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.HRESULT> focus_51;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT> put_accessKey_52;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_accessKey_53;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onblur_54;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onblur_55;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onfocus_56;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onfocus_57;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onresize_58;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onresize_59;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.HRESULT> blur_60;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Com.IUnknown* ,winmdroot.Foundation.HRESULT> addFilter_61;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Com.IUnknown* ,winmdroot.Foundation.HRESULT> removeFilter_62;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT> get_clientHeight_63;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT> get_clientWidth_64;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT> get_clientTop_65;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT> get_clientLeft_66;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.System.Com.IDispatch* ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT> attachEvent_67;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.System.Com.IDispatch* ,winmdroot.Foundation.HRESULT> detachEvent_68;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_readyState_69;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onreadystatechange_70;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onreadystatechange_71;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onrowsdelete_72;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onrowsdelete_73;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onrowsinserted_74;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onrowsinserted_75;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_oncellchange_76;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_oncellchange_77;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT> put_dir_78;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_dir_79;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT> createControlRange_80;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT> get_scrollHeight_81;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT> get_scrollWidth_82;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,winmdroot.Foundation.HRESULT> put_scrollTop_83;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT> get_scrollTop_84;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,winmdroot.Foundation.HRESULT> put_scrollLeft_85;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT> get_scrollLeft_86;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.HRESULT> clearAttributes_87;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLElement* ,winmdroot.Foundation.HRESULT> mergeAttributes_88;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_oncontextmenu_89;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_oncontextmenu_90;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Web.MsHtml.IHTMLElement* ,winmdroot.Web.MsHtml.IHTMLElement** ,winmdroot.Foundation.HRESULT> insertAdjacentElement_91;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLElement* ,winmdroot.Foundation.BSTR ,winmdroot.Web.MsHtml.IHTMLElement** ,winmdroot.Foundation.HRESULT> applyElement_92;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> getAdjacentText_93;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> replaceAdjacentText_94;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT> get_canHaveChildren_95;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.System.Variant.VARIANT* ,int* ,winmdroot.Foundation.HRESULT> addBehavior_96;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT> removeBehavior_97;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Web.MsHtml.IHTMLStyle** ,winmdroot.Foundation.HRESULT> get_runtimeStyle_98;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT> get_behaviorUrns_99;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT> put_tagUrn_100;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> get_tagUrn_101;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT> put_onbeforeeditfocus_102;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT> get_onbeforeeditfocus_103;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,int* ,winmdroot.Foundation.HRESULT> get_readyStateValue_104;

				internal delegate *unmanaged [Stdcall]<IHTMLElement2*,winmdroot.Foundation.BSTR ,winmdroot.Web.MsHtml.IHTMLElementCollection** ,winmdroot.Foundation.HRESULT> getElementsByTagName_105;
			} 
			public static void PopulateVTable(Vtbl* vtable)
			{
				vtable->get_scopeName_8 = &get_scopeName;
				vtable->setCapture_9 = &setCapture;
				vtable->releaseCapture_10 = &releaseCapture;
				vtable->put_onlosecapture_11 = &put_onlosecapture;
				vtable->get_onlosecapture_12 = &get_onlosecapture;
				vtable->componentFromPoint_13 = &componentFromPoint;
				vtable->doScroll_14 = &doScroll;
				vtable->put_onscroll_15 = &put_onscroll;
				vtable->get_onscroll_16 = &get_onscroll;
				vtable->put_ondrag_17 = &put_ondrag;
				vtable->get_ondrag_18 = &get_ondrag;
				vtable->put_ondragend_19 = &put_ondragend;
				vtable->get_ondragend_20 = &get_ondragend;
				vtable->put_ondragenter_21 = &put_ondragenter;
				vtable->get_ondragenter_22 = &get_ondragenter;
				vtable->put_ondragover_23 = &put_ondragover;
				vtable->get_ondragover_24 = &get_ondragover;
				vtable->put_ondragleave_25 = &put_ondragleave;
				vtable->get_ondragleave_26 = &get_ondragleave;
				vtable->put_ondrop_27 = &put_ondrop;
				vtable->get_ondrop_28 = &get_ondrop;
				vtable->put_onbeforecut_29 = &put_onbeforecut;
				vtable->get_onbeforecut_30 = &get_onbeforecut;
				vtable->put_oncut_31 = &put_oncut;
				vtable->get_oncut_32 = &get_oncut;
				vtable->put_onbeforecopy_33 = &put_onbeforecopy;
				vtable->get_onbeforecopy_34 = &get_onbeforecopy;
				vtable->put_oncopy_35 = &put_oncopy;
				vtable->get_oncopy_36 = &get_oncopy;
				vtable->put_onbeforepaste_37 = &put_onbeforepaste;
				vtable->get_onbeforepaste_38 = &get_onbeforepaste;
				vtable->put_onpaste_39 = &put_onpaste;
				vtable->get_onpaste_40 = &get_onpaste;
				vtable->get_currentStyle_41 = &get_currentStyle;
				vtable->put_onpropertychange_42 = &put_onpropertychange;
				vtable->get_onpropertychange_43 = &get_onpropertychange;
				vtable->getClientRects_44 = &getClientRects;
				vtable->getBoundingClientRect_45 = &getBoundingClientRect;
				vtable->setExpression_46 = &setExpression;
				vtable->getExpression_47 = &getExpression;
				vtable->removeExpression_48 = &removeExpression;
				vtable->put_tabIndex_49 = &put_tabIndex;
				vtable->get_tabIndex_50 = &get_tabIndex;
				vtable->focus_51 = &focus;
				vtable->put_accessKey_52 = &put_accessKey;
				vtable->get_accessKey_53 = &get_accessKey;
				vtable->put_onblur_54 = &put_onblur;
				vtable->get_onblur_55 = &get_onblur;
				vtable->put_onfocus_56 = &put_onfocus;
				vtable->get_onfocus_57 = &get_onfocus;
				vtable->put_onresize_58 = &put_onresize;
				vtable->get_onresize_59 = &get_onresize;
				vtable->blur_60 = &blur;
				vtable->addFilter_61 = &addFilter;
				vtable->removeFilter_62 = &removeFilter;
				vtable->get_clientHeight_63 = &get_clientHeight;
				vtable->get_clientWidth_64 = &get_clientWidth;
				vtable->get_clientTop_65 = &get_clientTop;
				vtable->get_clientLeft_66 = &get_clientLeft;
				vtable->attachEvent_67 = &attachEvent;
				vtable->detachEvent_68 = &detachEvent;
				vtable->get_readyState_69 = &get_readyState;
				vtable->put_onreadystatechange_70 = &put_onreadystatechange;
				vtable->get_onreadystatechange_71 = &get_onreadystatechange;
				vtable->put_onrowsdelete_72 = &put_onrowsdelete;
				vtable->get_onrowsdelete_73 = &get_onrowsdelete;
				vtable->put_onrowsinserted_74 = &put_onrowsinserted;
				vtable->get_onrowsinserted_75 = &get_onrowsinserted;
				vtable->put_oncellchange_76 = &put_oncellchange;
				vtable->get_oncellchange_77 = &get_oncellchange;
				vtable->put_dir_78 = &put_dir;
				vtable->get_dir_79 = &get_dir;
				vtable->createControlRange_80 = &createControlRange;
				vtable->get_scrollHeight_81 = &get_scrollHeight;
				vtable->get_scrollWidth_82 = &get_scrollWidth;
				vtable->put_scrollTop_83 = &put_scrollTop;
				vtable->get_scrollTop_84 = &get_scrollTop;
				vtable->put_scrollLeft_85 = &put_scrollLeft;
				vtable->get_scrollLeft_86 = &get_scrollLeft;
				vtable->clearAttributes_87 = &clearAttributes;
				vtable->mergeAttributes_88 = &mergeAttributes;
				vtable->put_oncontextmenu_89 = &put_oncontextmenu;
				vtable->get_oncontextmenu_90 = &get_oncontextmenu;
				vtable->insertAdjacentElement_91 = &insertAdjacentElement;
				vtable->applyElement_92 = &applyElement;
				vtable->getAdjacentText_93 = &getAdjacentText;
				vtable->replaceAdjacentText_94 = &replaceAdjacentText;
				vtable->get_canHaveChildren_95 = &get_canHaveChildren;
				vtable->addBehavior_96 = &addBehavior;
				vtable->removeBehavior_97 = &removeBehavior;
				vtable->get_runtimeStyle_98 = &get_runtimeStyle;
				vtable->get_behaviorUrns_99 = &get_behaviorUrns;
				vtable->put_tagUrn_100 = &put_tagUrn;
				vtable->get_tagUrn_101 = &get_tagUrn;
				vtable->put_onbeforeeditfocus_102 = &put_onbeforeeditfocus;
				vtable->get_onbeforeeditfocus_103 = &get_onbeforeeditfocus;
				vtable->get_readyStateValue_104 = &get_readyStateValue;
				vtable->getElementsByTagName_105 = &getElementsByTagName;
			}

			private void** lpVtbl;

			/// <summary>The IID guid for this interface.</summary>
			/// <value>{3050f434-98b5-11cf-bb82-00aa00bdce0b}</value>
			internal static readonly Guid IID_Guid = new Guid(0x3050F434, 0x98B5, 0x11CF, 0xBB, 0x82, 0x00, 0xAA, 0x00, 0xBD, 0xCE, 0x0B);

			static ref readonly Guid IComIID.Guid			{
								[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
				{
					ReadOnlySpan<byte> data = new byte[]					{
0x34,0xF4,0x50,0x30,0xB5,0x98,0xCF,0x11,0xBB,0x82,0x00,0xAA,0x00,0xBD,0xCE,0x0B					};
					return ref Unsafe.As<byte,Guid>(ref MemoryMarshal.GetReference(data));
				}
			}
			[Guid("3050F434-98B5-11CF-BB82-00AA00BDCE0B"),InterfaceType(ComInterfaceType.InterfaceIsDual),ComImport()]
			internal interface Interface
			{
				winmdroot.Foundation.BSTR scopeName
				{
					get;
				}

								[PreserveSig()]
winmdroot.Foundation.HRESULT setCapture(winmdroot.Foundation.VARIANT_BOOL containerCapture);

								[PreserveSig()]
winmdroot.Foundation.HRESULT releaseCapture();

				winmdroot.System.Variant.VARIANT onlosecapture
				{
					set;
					get;
				}

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT componentFromPoint(int x, int y, winmdroot.Foundation.BSTR* component);

								[PreserveSig()]
winmdroot.Foundation.HRESULT doScroll(winmdroot.System.Variant.VARIANT component);

				winmdroot.System.Variant.VARIANT onscroll
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT ondrag
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT ondragend
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT ondragenter
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT ondragover
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT ondragleave
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT ondrop
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onbeforecut
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT oncut
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onbeforecopy
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT oncopy
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onbeforepaste
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onpaste
				{
					set;
					get;
				}

				unsafe winmdroot.Web.MsHtml.IHTMLCurrentStyle* currentStyle
				{
					get;
				}

				winmdroot.System.Variant.VARIANT onpropertychange
				{
					set;
					get;
				}

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT getClientRects(winmdroot.Web.MsHtml.IHTMLRectCollection** pRectCol);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT getBoundingClientRect(winmdroot.Web.MsHtml.IHTMLRect** pRect);

								[PreserveSig()]
winmdroot.Foundation.HRESULT setExpression(winmdroot.Foundation.BSTR propname, winmdroot.Foundation.BSTR expression, winmdroot.Foundation.BSTR language);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT getExpression(winmdroot.Foundation.BSTR propname, winmdroot.System.Variant.VARIANT* expression);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT removeExpression(winmdroot.Foundation.BSTR propname, winmdroot.Foundation.VARIANT_BOOL* pfSuccess);

								[PreserveSig()]
winmdroot.Foundation.HRESULT put_tabIndex(short v);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_tabIndex(short* p);

								[PreserveSig()]
winmdroot.Foundation.HRESULT focus();

				winmdroot.Foundation.BSTR accessKey
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onblur
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onfocus
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onresize
				{
					set;
					get;
				}

								[PreserveSig()]
winmdroot.Foundation.HRESULT blur();

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT addFilter(winmdroot.System.Com.IUnknown* pUnk);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT removeFilter(winmdroot.System.Com.IUnknown* pUnk);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_clientHeight(int* p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_clientWidth(int* p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_clientTop(int* p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_clientLeft(int* p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT attachEvent(winmdroot.Foundation.BSTR @event, winmdroot.System.Com.IDispatch* pDisp, winmdroot.Foundation.VARIANT_BOOL* pfResult);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT detachEvent(winmdroot.Foundation.BSTR @event, winmdroot.System.Com.IDispatch* pDisp);

				winmdroot.System.Variant.VARIANT readyState
				{
					get;
				}

				winmdroot.System.Variant.VARIANT onreadystatechange
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onrowsdelete
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onrowsinserted
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT oncellchange
				{
					set;
					get;
				}

				winmdroot.Foundation.BSTR dir
				{
					set;
					get;
				}

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT createControlRange(winmdroot.System.Com.IDispatch** range);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_scrollHeight(int* p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_scrollWidth(int* p);

								[PreserveSig()]
winmdroot.Foundation.HRESULT put_scrollTop(int v);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_scrollTop(int* p);

								[PreserveSig()]
winmdroot.Foundation.HRESULT put_scrollLeft(int v);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_scrollLeft(int* p);

								[PreserveSig()]
winmdroot.Foundation.HRESULT clearAttributes();

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT mergeAttributes(winmdroot.Web.MsHtml.IHTMLElement* mergeThis);

				winmdroot.System.Variant.VARIANT oncontextmenu
				{
					set;
					get;
				}

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT insertAdjacentElement(winmdroot.Foundation.BSTR where, winmdroot.Web.MsHtml.IHTMLElement* insertedElement, winmdroot.Web.MsHtml.IHTMLElement** inserted);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT applyElement(winmdroot.Web.MsHtml.IHTMLElement* apply, winmdroot.Foundation.BSTR where, winmdroot.Web.MsHtml.IHTMLElement** applied);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT getAdjacentText(winmdroot.Foundation.BSTR where, winmdroot.Foundation.BSTR* text);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT replaceAdjacentText(winmdroot.Foundation.BSTR where, winmdroot.Foundation.BSTR newText, winmdroot.Foundation.BSTR* oldText);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_canHaveChildren(winmdroot.Foundation.VARIANT_BOOL* p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT addBehavior(winmdroot.Foundation.BSTR bstrUrl, winmdroot.System.Variant.VARIANT* pvarFactory, int* pCookie);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT removeBehavior(int cookie, winmdroot.Foundation.VARIANT_BOOL* pfResult);

				unsafe winmdroot.Web.MsHtml.IHTMLStyle* runtimeStyle
				{
					get;
				}

				unsafe winmdroot.System.Com.IDispatch* behaviorUrns
				{
					get;
				}

				winmdroot.Foundation.BSTR tagUrn
				{
					set;
					get;
				}

				winmdroot.System.Variant.VARIANT onbeforeeditfocus
				{
					set;
					get;
				}

				int readyStateValue
				{
					get;
				}

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT getElementsByTagName(winmdroot.Foundation.BSTR v, winmdroot.Web.MsHtml.IHTMLElementCollection** pelColl);
			}
		}
	}
}