// ------------------------------------------------------------------------------
// <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("3050F1FF-98B5-11CF-BB82-00AA00BDCE0B")]
		[global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
		internal unsafe partial struct IHTMLElement
			:IVTable<IHTMLElement,IHTMLElement.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]<IHTMLElement*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[0])((IHTMLElement*)Unsafe.AsPointer(ref this), riid, ppvObject);
			}

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

			public uint Release()
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,uint>)lpVtbl[2])((IHTMLElement*)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]<IHTMLElement*,uint* ,winmdroot.Foundation.HRESULT>)lpVtbl[3])((IHTMLElement*)Unsafe.AsPointer(ref this), pctinfo).ThrowOnFailure();
			}

			public unsafe void GetTypeInfo(uint iTInfo, uint lcid, winmdroot.System.Com.ITypeInfo** ppTInfo)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement*,uint ,uint ,winmdroot.System.Com.ITypeInfo** ,winmdroot.Foundation.HRESULT>)lpVtbl[4])((IHTMLElement*)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]<IHTMLElement*,global::System.Guid* ,winmdroot.Foundation.PWSTR* ,uint ,uint ,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[5])((IHTMLElement*)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]<IHTMLElement*,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])((IHTMLElement*)Unsafe.AsPointer(ref this), dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr).ThrowOnFailure();
			}

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

			public winmdroot.Foundation.HRESULT setAttribute(winmdroot.Foundation.BSTR strAttributeName, winmdroot.System.Variant.VARIANT AttributeValue, int lFlags)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,winmdroot.System.Variant.VARIANT ,int ,winmdroot.Foundation.HRESULT>)lpVtbl[7])((IHTMLElement*)Unsafe.AsPointer(ref this), strAttributeName, AttributeValue, lFlags);
			}

			/// <inheritdoc cref="getAttribute(winmdroot.Foundation.BSTR, int, winmdroot.System.Variant.VARIANT*)"/>
			internal unsafe winmdroot.Foundation.HRESULT getAttribute(winmdroot.Foundation.BSTR strAttributeName, int lFlags, out winmdroot.System.Variant.VARIANT AttributeValue)
			{
				fixed (winmdroot.System.Variant.VARIANT* AttributeValueLocal = &AttributeValue)
				{
					winmdroot.Foundation.HRESULT __result = this.getAttribute(strAttributeName, lFlags, AttributeValueLocal);
					return __result;
				}
			}

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

			public unsafe winmdroot.Foundation.HRESULT getAttribute(winmdroot.Foundation.BSTR strAttributeName, int lFlags, winmdroot.System.Variant.VARIANT* AttributeValue)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,int ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[8])((IHTMLElement*)Unsafe.AsPointer(ref this), strAttributeName, lFlags, AttributeValue);
			}

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

			public winmdroot.Foundation.VARIANT_BOOL removeAttribute(winmdroot.Foundation.BSTR strAttributeName, int lFlags)
			{
				winmdroot.Foundation.VARIANT_BOOL __retVal = default(winmdroot.Foundation.VARIANT_BOOL);
				((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,int ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[9])((IHTMLElement*)Unsafe.AsPointer(ref this), strAttributeName, lFlags, &__retVal).ThrowOnFailure();
				return __retVal;
			}

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

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_className(IHTMLElement* pThis, winmdroot.Foundation.BSTR* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.className;
					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_id(IHTMLElement* pThis, winmdroot.Foundation.BSTR v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.put_id(v);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.HRESULT put_id(winmdroot.Foundation.BSTR v)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[12])((IHTMLElement*)Unsafe.AsPointer(ref this), v);
			}

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

			public unsafe winmdroot.Foundation.HRESULT get_id(winmdroot.Foundation.BSTR* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[13])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

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

			public unsafe winmdroot.Foundation.HRESULT get_tagName(winmdroot.Foundation.BSTR* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[14])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

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

			public unsafe winmdroot.Foundation.HRESULT get_parentElement(winmdroot.Web.MsHtml.IHTMLElement** p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Web.MsHtml.IHTMLElement** ,winmdroot.Foundation.HRESULT>)lpVtbl[15])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

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

			public unsafe winmdroot.Foundation.HRESULT get_style(winmdroot.Web.MsHtml.IHTMLStyle** p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Web.MsHtml.IHTMLStyle** ,winmdroot.Foundation.HRESULT>)lpVtbl[16])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

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

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onhelp(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onhelp;
					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_onclick(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onclick = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onclick(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onclick;
					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_ondblclick(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondblclick = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondblclick(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondblclick;
					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_onkeydown(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onkeydown = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onkeydown(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onkeydown;
					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_onkeyup(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onkeyup = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onkeyup(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onkeyup;
					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_onkeypress(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onkeypress = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onkeypress(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onkeypress;
					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_onmouseout(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onmouseout = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onmouseout(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onmouseout;
					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_onmouseover(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onmouseover = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onmouseover(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onmouseover;
					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_onmousemove(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onmousemove = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onmousemove(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onmousemove;
					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_onmousedown(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onmousedown = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onmousedown(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onmousedown;
					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_onmouseup(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onmouseup = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onmouseup(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onmouseup;
					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_document(IHTMLElement* pThis, winmdroot.System.Com.IDispatch** p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_document(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_document(winmdroot.System.Com.IDispatch** p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT>)lpVtbl[39])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

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

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_title(IHTMLElement* pThis, winmdroot.Foundation.BSTR* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.title;
					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_language(IHTMLElement* pThis, winmdroot.Foundation.BSTR v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.language = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_language(IHTMLElement* pThis, winmdroot.Foundation.BSTR* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.language;
					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_onselectstart(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onselectstart = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onselectstart(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onselectstart;
					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 scrollIntoView(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT varargStart)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.scrollIntoView(varargStart);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public winmdroot.Foundation.HRESULT scrollIntoView(winmdroot.System.Variant.VARIANT varargStart)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.System.Variant.VARIANT ,winmdroot.Foundation.HRESULT>)lpVtbl[46])((IHTMLElement*)Unsafe.AsPointer(ref this), varargStart);
			}

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

			public unsafe winmdroot.Foundation.VARIANT_BOOL contains(winmdroot.Web.MsHtml.IHTMLElement* pChild)
			{
				winmdroot.Foundation.VARIANT_BOOL __retVal = default(winmdroot.Foundation.VARIANT_BOOL);
				((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Web.MsHtml.IHTMLElement* ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[47])((IHTMLElement*)Unsafe.AsPointer(ref this), pChild, &__retVal).ThrowOnFailure();
				return __retVal;
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public unsafe winmdroot.Foundation.HRESULT get_offsetParent(winmdroot.Web.MsHtml.IHTMLElement** p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Web.MsHtml.IHTMLElement** ,winmdroot.Foundation.HRESULT>)lpVtbl[56])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

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

			public winmdroot.Foundation.HRESULT put_innerHTML(winmdroot.Foundation.BSTR v)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[57])((IHTMLElement*)Unsafe.AsPointer(ref this), v);
			}

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

			public unsafe winmdroot.Foundation.HRESULT get_innerHTML(winmdroot.Foundation.BSTR* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[58])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

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

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

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

			public unsafe winmdroot.Foundation.HRESULT get_innerText(winmdroot.Foundation.BSTR* p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[60])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

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

			public winmdroot.Foundation.HRESULT put_outerHTML(winmdroot.Foundation.BSTR v)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[61])((IHTMLElement*)Unsafe.AsPointer(ref this), v);
			}

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

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

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

			public winmdroot.Foundation.HRESULT put_outerText(winmdroot.Foundation.BSTR v)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[63])((IHTMLElement*)Unsafe.AsPointer(ref this), v);
			}

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

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

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

			public void insertAdjacentHTML(winmdroot.Foundation.BSTR where, winmdroot.Foundation.BSTR html)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[65])((IHTMLElement*)Unsafe.AsPointer(ref this), where, html).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT insertAdjacentText(IHTMLElement* 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.insertAdjacentText(where, text);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public void insertAdjacentText(winmdroot.Foundation.BSTR where, winmdroot.Foundation.BSTR text)
			{
				((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[66])((IHTMLElement*)Unsafe.AsPointer(ref this), where, text).ThrowOnFailure();
			}

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

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

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

			internal winmdroot.Foundation.VARIANT_BOOL isTextEdit
			{
				get
				{
					winmdroot.Foundation.VARIANT_BOOL __result;
					((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[68])((IHTMLElement*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

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

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

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

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

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

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondragstart(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondragstart;
					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 toString(IHTMLElement* pThis, winmdroot.Foundation.BSTR* String)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.toString(String);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

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

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onbeforeupdate(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onbeforeupdate;
					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_onafterupdate(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onafterupdate = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onafterupdate(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onafterupdate;
					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_onerrorupdate(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onerrorupdate = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onerrorupdate(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onerrorupdate;
					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_onrowexit(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onrowexit = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onrowexit(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onrowexit;
					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_onrowenter(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onrowenter = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onrowenter(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onrowenter;
					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_ondatasetchanged(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondatasetchanged = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondatasetchanged(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondatasetchanged;
					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_ondataavailable(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondataavailable = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondataavailable(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondataavailable;
					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_ondatasetcomplete(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.ondatasetcomplete = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_ondatasetcomplete(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.ondatasetcomplete;
					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_onfilterchange(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.onfilterchange = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_onfilterchange(IHTMLElement* pThis, winmdroot.System.Variant.VARIANT* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.onfilterchange;
					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_children(IHTMLElement* pThis, winmdroot.System.Com.IDispatch** p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.get_children(p);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			public unsafe winmdroot.Foundation.HRESULT get_children(winmdroot.System.Com.IDispatch** p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT>)lpVtbl[92])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

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

			public unsafe winmdroot.Foundation.HRESULT get_all(winmdroot.System.Com.IDispatch** p)
			{
				return ((delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT>)lpVtbl[93])((IHTMLElement*)Unsafe.AsPointer(ref this), p);
			}

			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]<IHTMLElement*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT> QueryInterface_1;

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

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

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

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

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

				internal delegate *unmanaged [Stdcall]<IHTMLElement*,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]<IHTMLElement*,winmdroot.Foundation.BSTR ,winmdroot.System.Variant.VARIANT ,int ,winmdroot.Foundation.HRESULT> setAttribute_8;

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

				internal delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.BSTR ,int ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT> removeAttribute_10;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

				internal delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.Foundation.HRESULT> click_70;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

				internal delegate *unmanaged [Stdcall]<IHTMLElement*,winmdroot.System.Com.IDispatch** ,winmdroot.Foundation.HRESULT> get_all_94;
			} 
			public static void PopulateVTable(Vtbl* vtable)
			{
				vtable->setAttribute_8 = &setAttribute;
				vtable->getAttribute_9 = &getAttribute;
				vtable->removeAttribute_10 = &removeAttribute;
				vtable->put_className_11 = &put_className;
				vtable->get_className_12 = &get_className;
				vtable->put_id_13 = &put_id;
				vtable->get_id_14 = &get_id;
				vtable->get_tagName_15 = &get_tagName;
				vtable->get_parentElement_16 = &get_parentElement;
				vtable->get_style_17 = &get_style;
				vtable->put_onhelp_18 = &put_onhelp;
				vtable->get_onhelp_19 = &get_onhelp;
				vtable->put_onclick_20 = &put_onclick;
				vtable->get_onclick_21 = &get_onclick;
				vtable->put_ondblclick_22 = &put_ondblclick;
				vtable->get_ondblclick_23 = &get_ondblclick;
				vtable->put_onkeydown_24 = &put_onkeydown;
				vtable->get_onkeydown_25 = &get_onkeydown;
				vtable->put_onkeyup_26 = &put_onkeyup;
				vtable->get_onkeyup_27 = &get_onkeyup;
				vtable->put_onkeypress_28 = &put_onkeypress;
				vtable->get_onkeypress_29 = &get_onkeypress;
				vtable->put_onmouseout_30 = &put_onmouseout;
				vtable->get_onmouseout_31 = &get_onmouseout;
				vtable->put_onmouseover_32 = &put_onmouseover;
				vtable->get_onmouseover_33 = &get_onmouseover;
				vtable->put_onmousemove_34 = &put_onmousemove;
				vtable->get_onmousemove_35 = &get_onmousemove;
				vtable->put_onmousedown_36 = &put_onmousedown;
				vtable->get_onmousedown_37 = &get_onmousedown;
				vtable->put_onmouseup_38 = &put_onmouseup;
				vtable->get_onmouseup_39 = &get_onmouseup;
				vtable->get_document_40 = &get_document;
				vtable->put_title_41 = &put_title;
				vtable->get_title_42 = &get_title;
				vtable->put_language_43 = &put_language;
				vtable->get_language_44 = &get_language;
				vtable->put_onselectstart_45 = &put_onselectstart;
				vtable->get_onselectstart_46 = &get_onselectstart;
				vtable->scrollIntoView_47 = &scrollIntoView;
				vtable->contains_48 = &contains;
				vtable->get_sourceIndex_49 = &get_sourceIndex;
				vtable->get_recordNumber_50 = &get_recordNumber;
				vtable->put_lang_51 = &put_lang;
				vtable->get_lang_52 = &get_lang;
				vtable->get_offsetLeft_53 = &get_offsetLeft;
				vtable->get_offsetTop_54 = &get_offsetTop;
				vtable->get_offsetWidth_55 = &get_offsetWidth;
				vtable->get_offsetHeight_56 = &get_offsetHeight;
				vtable->get_offsetParent_57 = &get_offsetParent;
				vtable->put_innerHTML_58 = &put_innerHTML;
				vtable->get_innerHTML_59 = &get_innerHTML;
				vtable->put_innerText_60 = &put_innerText;
				vtable->get_innerText_61 = &get_innerText;
				vtable->put_outerHTML_62 = &put_outerHTML;
				vtable->get_outerHTML_63 = &get_outerHTML;
				vtable->put_outerText_64 = &put_outerText;
				vtable->get_outerText_65 = &get_outerText;
				vtable->insertAdjacentHTML_66 = &insertAdjacentHTML;
				vtable->insertAdjacentText_67 = &insertAdjacentText;
				vtable->get_parentTextEdit_68 = &get_parentTextEdit;
				vtable->get_isTextEdit_69 = &get_isTextEdit;
				vtable->click_70 = &click;
				vtable->get_filters_71 = &get_filters;
				vtable->put_ondragstart_72 = &put_ondragstart;
				vtable->get_ondragstart_73 = &get_ondragstart;
				vtable->toString_74 = &toString;
				vtable->put_onbeforeupdate_75 = &put_onbeforeupdate;
				vtable->get_onbeforeupdate_76 = &get_onbeforeupdate;
				vtable->put_onafterupdate_77 = &put_onafterupdate;
				vtable->get_onafterupdate_78 = &get_onafterupdate;
				vtable->put_onerrorupdate_79 = &put_onerrorupdate;
				vtable->get_onerrorupdate_80 = &get_onerrorupdate;
				vtable->put_onrowexit_81 = &put_onrowexit;
				vtable->get_onrowexit_82 = &get_onrowexit;
				vtable->put_onrowenter_83 = &put_onrowenter;
				vtable->get_onrowenter_84 = &get_onrowenter;
				vtable->put_ondatasetchanged_85 = &put_ondatasetchanged;
				vtable->get_ondatasetchanged_86 = &get_ondatasetchanged;
				vtable->put_ondataavailable_87 = &put_ondataavailable;
				vtable->get_ondataavailable_88 = &get_ondataavailable;
				vtable->put_ondatasetcomplete_89 = &put_ondatasetcomplete;
				vtable->get_ondatasetcomplete_90 = &get_ondatasetcomplete;
				vtable->put_onfilterchange_91 = &put_onfilterchange;
				vtable->get_onfilterchange_92 = &get_onfilterchange;
				vtable->get_children_93 = &get_children;
				vtable->get_all_94 = &get_all;
			}

			private void** lpVtbl;

			/// <summary>The IID guid for this interface.</summary>
			/// <value>{3050f1ff-98b5-11cf-bb82-00aa00bdce0b}</value>
			internal static readonly Guid IID_Guid = new Guid(0x3050F1FF, 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[]					{
0xFF,0xF1,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("3050F1FF-98B5-11CF-BB82-00AA00BDCE0B"),InterfaceType(ComInterfaceType.InterfaceIsDual),ComImport()]
			internal interface Interface
			{
								[PreserveSig()]
winmdroot.Foundation.HRESULT setAttribute(winmdroot.Foundation.BSTR strAttributeName, winmdroot.System.Variant.VARIANT AttributeValue, int lFlags);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT getAttribute(winmdroot.Foundation.BSTR strAttributeName, int lFlags, winmdroot.System.Variant.VARIANT* AttributeValue);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT removeAttribute(winmdroot.Foundation.BSTR strAttributeName, int lFlags, winmdroot.Foundation.VARIANT_BOOL* pfSuccess);

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

								[PreserveSig()]
winmdroot.Foundation.HRESULT put_id(winmdroot.Foundation.BSTR v);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_id(winmdroot.Foundation.BSTR* p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_tagName(winmdroot.Foundation.BSTR* p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_parentElement(winmdroot.Web.MsHtml.IHTMLElement** p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_style(winmdroot.Web.MsHtml.IHTMLStyle** p);

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

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

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

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

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

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

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

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

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

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

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

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_document(winmdroot.System.Com.IDispatch** p);

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

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

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

								[PreserveSig()]
winmdroot.Foundation.HRESULT scrollIntoView(winmdroot.System.Variant.VARIANT varargStart);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT contains(winmdroot.Web.MsHtml.IHTMLElement* pChild, winmdroot.Foundation.VARIANT_BOOL* pfResult);

				int sourceIndex
				{
					get;
				}

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

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

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

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

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

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

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_offsetParent(winmdroot.Web.MsHtml.IHTMLElement** p);

								[PreserveSig()]
winmdroot.Foundation.HRESULT put_innerHTML(winmdroot.Foundation.BSTR v);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_innerHTML(winmdroot.Foundation.BSTR* p);

								[PreserveSig()]
winmdroot.Foundation.HRESULT put_innerText(winmdroot.Foundation.BSTR v);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_innerText(winmdroot.Foundation.BSTR* p);

								[PreserveSig()]
winmdroot.Foundation.HRESULT put_outerHTML(winmdroot.Foundation.BSTR v);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_outerHTML(winmdroot.Foundation.BSTR* p);

								[PreserveSig()]
winmdroot.Foundation.HRESULT put_outerText(winmdroot.Foundation.BSTR v);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_outerText(winmdroot.Foundation.BSTR* p);

								[PreserveSig()]
winmdroot.Foundation.HRESULT insertAdjacentHTML(winmdroot.Foundation.BSTR where, winmdroot.Foundation.BSTR html);

								[PreserveSig()]
winmdroot.Foundation.HRESULT insertAdjacentText(winmdroot.Foundation.BSTR where, winmdroot.Foundation.BSTR text);

				unsafe winmdroot.Web.MsHtml.IHTMLElement* parentTextEdit
				{
					get;
				}

				winmdroot.Foundation.VARIANT_BOOL isTextEdit
				{
					get;
				}

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

				unsafe winmdroot.Web.MsHtml.IHTMLFiltersCollection* filters
				{
					get;
				}

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

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT toString(winmdroot.Foundation.BSTR* String);

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

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

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

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

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

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

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

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

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

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_children(winmdroot.System.Com.IDispatch** p);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT get_all(winmdroot.System.Com.IDispatch** p);
			}
		}
	}
}