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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_textDecorationNone(IHTMLStyle* pThis, winmdroot.Foundation.VARIANT_BOOL* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.textDecorationNone;
					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_textDecorationUnderline(IHTMLStyle* pThis, winmdroot.Foundation.VARIANT_BOOL v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.textDecorationUnderline = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.Foundation.VARIANT_BOOL textDecorationUnderline
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,winmdroot.Foundation.VARIANT_BOOL ,winmdroot.Foundation.HRESULT>)lpVtbl[45])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.Foundation.VARIANT_BOOL __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[46])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_textDecorationUnderline(IHTMLStyle* pThis, winmdroot.Foundation.VARIANT_BOOL* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.textDecorationUnderline;
					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_textDecorationOverline(IHTMLStyle* pThis, winmdroot.Foundation.VARIANT_BOOL v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.textDecorationOverline = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal winmdroot.Foundation.VARIANT_BOOL textDecorationOverline
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,winmdroot.Foundation.VARIANT_BOOL ,winmdroot.Foundation.HRESULT>)lpVtbl[47])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					winmdroot.Foundation.VARIANT_BOOL __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[48])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_textDecorationOverline(IHTMLStyle* pThis, winmdroot.Foundation.VARIANT_BOOL* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.textDecorationOverline;
					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_textDecorationLineThrough(IHTMLStyle* pThis, winmdroot.Foundation.VARIANT_BOOL v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.textDecorationLineThrough = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_textDecorationLineThrough(IHTMLStyle* pThis, winmdroot.Foundation.VARIANT_BOOL* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.textDecorationLineThrough;
					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_textDecorationBlink(IHTMLStyle* pThis, winmdroot.Foundation.VARIANT_BOOL v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.textDecorationBlink = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal int pixelTop
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[160])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					int __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[161])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_pixelTop(IHTMLStyle* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.pixelTop;
					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_pixelLeft(IHTMLStyle* pThis, int v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.pixelLeft = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal int pixelLeft
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[162])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					int __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[163])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_pixelLeft(IHTMLStyle* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.pixelLeft;
					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_pixelWidth(IHTMLStyle* pThis, int v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.pixelWidth = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal int pixelWidth
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[164])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					int __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[165])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_pixelWidth(IHTMLStyle* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.pixelWidth;
					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_pixelHeight(IHTMLStyle* pThis, int v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.pixelHeight = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal int pixelHeight
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[166])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					int __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[167])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_pixelHeight(IHTMLStyle* pThis, int* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.pixelHeight;
					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_posTop(IHTMLStyle* pThis, float v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.posTop = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal float posTop
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[168])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					float __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[169])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_posTop(IHTMLStyle* pThis, float* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.posTop;
					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_posLeft(IHTMLStyle* pThis, float v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.posLeft = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal float posLeft
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[170])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					float __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[171])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_posLeft(IHTMLStyle* pThis, float* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.posLeft;
					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_posWidth(IHTMLStyle* pThis, float v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.posWidth = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal float posWidth
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[172])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					float __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[173])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_posWidth(IHTMLStyle* pThis, float* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.posWidth;
					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_posHeight(IHTMLStyle* pThis, float v)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					__object.posHeight = v;
					return winmdroot.Foundation.HRESULT.S_OK;
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			internal float posHeight
			{
				set
				{
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[174])((IHTMLStyle*)Unsafe.AsPointer(ref this), value).ThrowOnFailure();
				}
				get
				{
					float __result;
					((delegate *unmanaged [Stdcall]<IHTMLStyle*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[175])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__result).ThrowOnFailure();
					return __result;
				}
			}

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

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

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

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

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

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

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT get_filter(IHTMLStyle* pThis, winmdroot.Foundation.BSTR* p)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					*p = __object.filter;
					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 setAttribute(IHTMLStyle* 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 void setAttribute(winmdroot.Foundation.BSTR strAttributeName, winmdroot.System.Variant.VARIANT AttributeValue, int lFlags)
			{
				((delegate *unmanaged [Stdcall]<IHTMLStyle*,winmdroot.Foundation.BSTR ,winmdroot.System.Variant.VARIANT ,int ,winmdroot.Foundation.HRESULT>)lpVtbl[182])((IHTMLStyle*)Unsafe.AsPointer(ref this), strAttributeName, AttributeValue, lFlags).ThrowOnFailure();
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT getAttribute(IHTMLStyle* 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 winmdroot.System.Variant.VARIANT getAttribute(winmdroot.Foundation.BSTR strAttributeName, int lFlags)
			{
				winmdroot.System.Variant.VARIANT __retVal = default(winmdroot.System.Variant.VARIANT);
				((delegate *unmanaged [Stdcall]<IHTMLStyle*,winmdroot.Foundation.BSTR ,int ,winmdroot.System.Variant.VARIANT* ,winmdroot.Foundation.HRESULT>)lpVtbl[183])((IHTMLStyle*)Unsafe.AsPointer(ref this), strAttributeName, lFlags, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT removeAttribute(IHTMLStyle* 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]<IHTMLStyle*,winmdroot.Foundation.BSTR ,int ,winmdroot.Foundation.VARIANT_BOOL* ,winmdroot.Foundation.HRESULT>)lpVtbl[184])((IHTMLStyle*)Unsafe.AsPointer(ref this), strAttributeName, lFlags, &__retVal).ThrowOnFailure();
				return __retVal;
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT toString(IHTMLStyle* 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]<IHTMLStyle*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[185])((IHTMLStyle*)Unsafe.AsPointer(ref this), &__retVal).ThrowOnFailure();
				return __retVal;
			}

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

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

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

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

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

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

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,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]<IHTMLStyle*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT> put_fontFamily_8;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,float ,winmdroot.Foundation.HRESULT> put_posTop_169;

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,float* ,winmdroot.Foundation.HRESULT> get_posTop_170;

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,float ,winmdroot.Foundation.HRESULT> put_posLeft_171;

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,float* ,winmdroot.Foundation.HRESULT> get_posLeft_172;

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,float ,winmdroot.Foundation.HRESULT> put_posWidth_173;

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,float* ,winmdroot.Foundation.HRESULT> get_posWidth_174;

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,float ,winmdroot.Foundation.HRESULT> put_posHeight_175;

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,float* ,winmdroot.Foundation.HRESULT> get_posHeight_176;

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

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

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

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

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

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

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

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

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

				internal delegate *unmanaged [Stdcall]<IHTMLStyle*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT> toString_186;
			} 
			public static void PopulateVTable(Vtbl* vtable)
			{
				vtable->put_fontFamily_8 = &put_fontFamily;
				vtable->get_fontFamily_9 = &get_fontFamily;
				vtable->put_fontStyle_10 = &put_fontStyle;
				vtable->get_fontStyle_11 = &get_fontStyle;
				vtable->put_fontVariant_12 = &put_fontVariant;
				vtable->get_fontVariant_13 = &get_fontVariant;
				vtable->put_fontWeight_14 = &put_fontWeight;
				vtable->get_fontWeight_15 = &get_fontWeight;
				vtable->put_fontSize_16 = &put_fontSize;
				vtable->get_fontSize_17 = &get_fontSize;
				vtable->put_font_18 = &put_font;
				vtable->get_font_19 = &get_font;
				vtable->put_color_20 = &put_color;
				vtable->get_color_21 = &get_color;
				vtable->put_background_22 = &put_background;
				vtable->get_background_23 = &get_background;
				vtable->put_backgroundColor_24 = &put_backgroundColor;
				vtable->get_backgroundColor_25 = &get_backgroundColor;
				vtable->put_backgroundImage_26 = &put_backgroundImage;
				vtable->get_backgroundImage_27 = &get_backgroundImage;
				vtable->put_backgroundRepeat_28 = &put_backgroundRepeat;
				vtable->get_backgroundRepeat_29 = &get_backgroundRepeat;
				vtable->put_backgroundAttachment_30 = &put_backgroundAttachment;
				vtable->get_backgroundAttachment_31 = &get_backgroundAttachment;
				vtable->put_backgroundPosition_32 = &put_backgroundPosition;
				vtable->get_backgroundPosition_33 = &get_backgroundPosition;
				vtable->put_backgroundPositionX_34 = &put_backgroundPositionX;
				vtable->get_backgroundPositionX_35 = &get_backgroundPositionX;
				vtable->put_backgroundPositionY_36 = &put_backgroundPositionY;
				vtable->get_backgroundPositionY_37 = &get_backgroundPositionY;
				vtable->put_wordSpacing_38 = &put_wordSpacing;
				vtable->get_wordSpacing_39 = &get_wordSpacing;
				vtable->put_letterSpacing_40 = &put_letterSpacing;
				vtable->get_letterSpacing_41 = &get_letterSpacing;
				vtable->put_textDecoration_42 = &put_textDecoration;
				vtable->get_textDecoration_43 = &get_textDecoration;
				vtable->put_textDecorationNone_44 = &put_textDecorationNone;
				vtable->get_textDecorationNone_45 = &get_textDecorationNone;
				vtable->put_textDecorationUnderline_46 = &put_textDecorationUnderline;
				vtable->get_textDecorationUnderline_47 = &get_textDecorationUnderline;
				vtable->put_textDecorationOverline_48 = &put_textDecorationOverline;
				vtable->get_textDecorationOverline_49 = &get_textDecorationOverline;
				vtable->put_textDecorationLineThrough_50 = &put_textDecorationLineThrough;
				vtable->get_textDecorationLineThrough_51 = &get_textDecorationLineThrough;
				vtable->put_textDecorationBlink_52 = &put_textDecorationBlink;
				vtable->get_textDecorationBlink_53 = &get_textDecorationBlink;
				vtable->put_verticalAlign_54 = &put_verticalAlign;
				vtable->get_verticalAlign_55 = &get_verticalAlign;
				vtable->put_textTransform_56 = &put_textTransform;
				vtable->get_textTransform_57 = &get_textTransform;
				vtable->put_textAlign_58 = &put_textAlign;
				vtable->get_textAlign_59 = &get_textAlign;
				vtable->put_textIndent_60 = &put_textIndent;
				vtable->get_textIndent_61 = &get_textIndent;
				vtable->put_lineHeight_62 = &put_lineHeight;
				vtable->get_lineHeight_63 = &get_lineHeight;
				vtable->put_marginTop_64 = &put_marginTop;
				vtable->get_marginTop_65 = &get_marginTop;
				vtable->put_marginRight_66 = &put_marginRight;
				vtable->get_marginRight_67 = &get_marginRight;
				vtable->put_marginBottom_68 = &put_marginBottom;
				vtable->get_marginBottom_69 = &get_marginBottom;
				vtable->put_marginLeft_70 = &put_marginLeft;
				vtable->get_marginLeft_71 = &get_marginLeft;
				vtable->put_margin_72 = &put_margin;
				vtable->get_margin_73 = &get_margin;
				vtable->put_paddingTop_74 = &put_paddingTop;
				vtable->get_paddingTop_75 = &get_paddingTop;
				vtable->put_paddingRight_76 = &put_paddingRight;
				vtable->get_paddingRight_77 = &get_paddingRight;
				vtable->put_paddingBottom_78 = &put_paddingBottom;
				vtable->get_paddingBottom_79 = &get_paddingBottom;
				vtable->put_paddingLeft_80 = &put_paddingLeft;
				vtable->get_paddingLeft_81 = &get_paddingLeft;
				vtable->put_padding_82 = &put_padding;
				vtable->get_padding_83 = &get_padding;
				vtable->put_border_84 = &put_border;
				vtable->get_border_85 = &get_border;
				vtable->put_borderTop_86 = &put_borderTop;
				vtable->get_borderTop_87 = &get_borderTop;
				vtable->put_borderRight_88 = &put_borderRight;
				vtable->get_borderRight_89 = &get_borderRight;
				vtable->put_borderBottom_90 = &put_borderBottom;
				vtable->get_borderBottom_91 = &get_borderBottom;
				vtable->put_borderLeft_92 = &put_borderLeft;
				vtable->get_borderLeft_93 = &get_borderLeft;
				vtable->put_borderColor_94 = &put_borderColor;
				vtable->get_borderColor_95 = &get_borderColor;
				vtable->put_borderTopColor_96 = &put_borderTopColor;
				vtable->get_borderTopColor_97 = &get_borderTopColor;
				vtable->put_borderRightColor_98 = &put_borderRightColor;
				vtable->get_borderRightColor_99 = &get_borderRightColor;
				vtable->put_borderBottomColor_100 = &put_borderBottomColor;
				vtable->get_borderBottomColor_101 = &get_borderBottomColor;
				vtable->put_borderLeftColor_102 = &put_borderLeftColor;
				vtable->get_borderLeftColor_103 = &get_borderLeftColor;
				vtable->put_borderWidth_104 = &put_borderWidth;
				vtable->get_borderWidth_105 = &get_borderWidth;
				vtable->put_borderTopWidth_106 = &put_borderTopWidth;
				vtable->get_borderTopWidth_107 = &get_borderTopWidth;
				vtable->put_borderRightWidth_108 = &put_borderRightWidth;
				vtable->get_borderRightWidth_109 = &get_borderRightWidth;
				vtable->put_borderBottomWidth_110 = &put_borderBottomWidth;
				vtable->get_borderBottomWidth_111 = &get_borderBottomWidth;
				vtable->put_borderLeftWidth_112 = &put_borderLeftWidth;
				vtable->get_borderLeftWidth_113 = &get_borderLeftWidth;
				vtable->put_borderStyle_114 = &put_borderStyle;
				vtable->get_borderStyle_115 = &get_borderStyle;
				vtable->put_borderTopStyle_116 = &put_borderTopStyle;
				vtable->get_borderTopStyle_117 = &get_borderTopStyle;
				vtable->put_borderRightStyle_118 = &put_borderRightStyle;
				vtable->get_borderRightStyle_119 = &get_borderRightStyle;
				vtable->put_borderBottomStyle_120 = &put_borderBottomStyle;
				vtable->get_borderBottomStyle_121 = &get_borderBottomStyle;
				vtable->put_borderLeftStyle_122 = &put_borderLeftStyle;
				vtable->get_borderLeftStyle_123 = &get_borderLeftStyle;
				vtable->put_width_124 = &put_width;
				vtable->get_width_125 = &get_width;
				vtable->put_height_126 = &put_height;
				vtable->get_height_127 = &get_height;
				vtable->put_styleFloat_128 = &put_styleFloat;
				vtable->get_styleFloat_129 = &get_styleFloat;
				vtable->put_clear_130 = &put_clear;
				vtable->get_clear_131 = &get_clear;
				vtable->put_display_132 = &put_display;
				vtable->get_display_133 = &get_display;
				vtable->put_visibility_134 = &put_visibility;
				vtable->get_visibility_135 = &get_visibility;
				vtable->put_listStyleType_136 = &put_listStyleType;
				vtable->get_listStyleType_137 = &get_listStyleType;
				vtable->put_listStylePosition_138 = &put_listStylePosition;
				vtable->get_listStylePosition_139 = &get_listStylePosition;
				vtable->put_listStyleImage_140 = &put_listStyleImage;
				vtable->get_listStyleImage_141 = &get_listStyleImage;
				vtable->put_listStyle_142 = &put_listStyle;
				vtable->get_listStyle_143 = &get_listStyle;
				vtable->put_whiteSpace_144 = &put_whiteSpace;
				vtable->get_whiteSpace_145 = &get_whiteSpace;
				vtable->put_top_146 = &put_top;
				vtable->get_top_147 = &get_top;
				vtable->put_left_148 = &put_left;
				vtable->get_left_149 = &get_left;
				vtable->get_position_150 = &get_position;
				vtable->put_zIndex_151 = &put_zIndex;
				vtable->get_zIndex_152 = &get_zIndex;
				vtable->put_overflow_153 = &put_overflow;
				vtable->get_overflow_154 = &get_overflow;
				vtable->put_pageBreakBefore_155 = &put_pageBreakBefore;
				vtable->get_pageBreakBefore_156 = &get_pageBreakBefore;
				vtable->put_pageBreakAfter_157 = &put_pageBreakAfter;
				vtable->get_pageBreakAfter_158 = &get_pageBreakAfter;
				vtable->put_cssText_159 = &put_cssText;
				vtable->get_cssText_160 = &get_cssText;
				vtable->put_pixelTop_161 = &put_pixelTop;
				vtable->get_pixelTop_162 = &get_pixelTop;
				vtable->put_pixelLeft_163 = &put_pixelLeft;
				vtable->get_pixelLeft_164 = &get_pixelLeft;
				vtable->put_pixelWidth_165 = &put_pixelWidth;
				vtable->get_pixelWidth_166 = &get_pixelWidth;
				vtable->put_pixelHeight_167 = &put_pixelHeight;
				vtable->get_pixelHeight_168 = &get_pixelHeight;
				vtable->put_posTop_169 = &put_posTop;
				vtable->get_posTop_170 = &get_posTop;
				vtable->put_posLeft_171 = &put_posLeft;
				vtable->get_posLeft_172 = &get_posLeft;
				vtable->put_posWidth_173 = &put_posWidth;
				vtable->get_posWidth_174 = &get_posWidth;
				vtable->put_posHeight_175 = &put_posHeight;
				vtable->get_posHeight_176 = &get_posHeight;
				vtable->put_cursor_177 = &put_cursor;
				vtable->get_cursor_178 = &get_cursor;
				vtable->put_clip_179 = &put_clip;
				vtable->get_clip_180 = &get_clip;
				vtable->put_filter_181 = &put_filter;
				vtable->get_filter_182 = &get_filter;
				vtable->setAttribute_183 = &setAttribute;
				vtable->getAttribute_184 = &getAttribute;
				vtable->removeAttribute_185 = &removeAttribute;
				vtable->toString_186 = &toString;
			}

			private void** lpVtbl;

			/// <summary>The IID guid for this interface.</summary>
			/// <value>{3050f25e-98b5-11cf-bb82-00aa00bdce0b}</value>
			internal static readonly Guid IID_Guid = new Guid(0x3050F25E, 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[]					{
0x5E,0xF2,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("3050F25E-98B5-11CF-BB82-00AA00BDCE0B"),InterfaceType(ComInterfaceType.InterfaceIsDual),ComImport()]
			internal interface Interface
			{
				winmdroot.Foundation.BSTR fontFamily
				{
					set;
					get;
				}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

				winmdroot.Foundation.VARIANT_BOOL textDecorationNone
				{
					set;
					get;
				}

				winmdroot.Foundation.VARIANT_BOOL textDecorationUnderline
				{
					set;
					get;
				}

				winmdroot.Foundation.VARIANT_BOOL textDecorationOverline
				{
					set;
					get;
				}

				winmdroot.Foundation.VARIANT_BOOL textDecorationLineThrough
				{
					set;
					get;
				}

				winmdroot.Foundation.VARIANT_BOOL textDecorationBlink
				{
					set;
					get;
				}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

				winmdroot.Foundation.BSTR position
				{
					get;
				}

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

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

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

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

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

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

				int pixelTop
				{
					set;
					get;
				}

				int pixelLeft
				{
					set;
					get;
				}

				int pixelWidth
				{
					set;
					get;
				}

				int pixelHeight
				{
					set;
					get;
				}

				float posTop
				{
					set;
					get;
				}

				float posLeft
				{
					set;
					get;
				}

				float posWidth
				{
					set;
					get;
				}

				float posHeight
				{
					set;
					get;
				}

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

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

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

								[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);

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