// ------------------------------------------------------------------------------
// <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 UI.Controls.RichEdit
	{
		[Guid("8CC497C3-A1DF-11CE-8098-00AA0047BE5D")]
		[SupportedOSPlatform("windows6.0.6000")]
		[global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
		internal unsafe partial struct ITextFont
			:IVTable<ITextFont,ITextFont.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]<ITextFont*,global::System.Guid* ,void** ,winmdroot.Foundation.HRESULT>)lpVtbl[0])((ITextFont*)Unsafe.AsPointer(ref this), riid, ppvObject);
			}

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

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

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

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

			/// <summary>Gets a duplicate of this text font object.</summary>
			/// <param name="ppFont">
			/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextfont">ITextFont</a>**</b> The duplicate text font object.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getduplicate#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para>The duplicate property is the default property of an <a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextfont">ITextFont</a> object. For an example of how to use font duplicates, see <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextrange-setfont">SetFont</a>.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getduplicate#">Read more on docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetDuplicate(winmdroot.UI.Controls.RichEdit.ITextFont** ppFont)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,winmdroot.UI.Controls.RichEdit.ITextFont** ,winmdroot.Foundation.HRESULT>)lpVtbl[7])((ITextFont*)Unsafe.AsPointer(ref this), ppFont).ThrowOnFailure();
			}

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

			/// <summary>Sets the character formatting by copying another text font object.</summary>
			/// <param name="pFont">
			/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextfont">ITextFont</a>*</b> The text font object to apply to this font object.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setduplicate#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para>Values with the <b>tomUndefined</b> attribute have no effect. For an example of how to use font duplicates, see <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextrange-setfont">SetFont</a>.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setduplicate#">Read more on docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void SetDuplicate([Optional] winmdroot.UI.Controls.RichEdit.ITextFont* pFont)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,winmdroot.UI.Controls.RichEdit.ITextFont* ,winmdroot.Foundation.HRESULT>)lpVtbl[8])((ITextFont*)Unsafe.AsPointer(ref this), pFont).ThrowOnFailure();
			}

			/// <inheritdoc cref="CanChange(int*)"/>
			internal unsafe void CanChange(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.CanChange(pValueLocal);
				}
			}

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

			/// <summary>Determines whether the font can be changed.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A variable that is <b>tomTrue</b> if the font can be changed or <b>tomFalse</b> if it cannot be changed. This parameter can be <b>NULL</b>.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-canchange#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the font can change, the method returns <b>S_OK</b>. If the method fails, it returns the following COM error code. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>The *<i>pbCanChange</i> returns <b>tomTrue</b> only if the font can be changed. That is, no part of an associated range is protected and an associated document is not read-only. If this <a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextfont">ITextFont</a> object is a duplicate, no protection rules apply.</remarks>
			public unsafe void CanChange(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[9])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

			/// <inheritdoc cref="IsEqual(winmdroot.UI.Controls.RichEdit.ITextFont*, int*)"/>
			internal unsafe void IsEqual(winmdroot.UI.Controls.RichEdit.ITextFont* pFont, out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.IsEqual(pFont, pValueLocal);
				}
			}

			[UnmanagedCallersOnly(CallConvs = new []{
typeof(CallConvStdcall)}
)]
			private static winmdroot.Foundation.HRESULT IsEqual(ITextFont* pThis, [Optional] winmdroot.UI.Controls.RichEdit.ITextFont* pFont, int* pValue)
			{
				try
				{
					winmdroot.Foundation.HRESULT __hr = ComHelpers.UnwrapCCW(pThis, out Interface __object);
					if (__hr.Failed)
					{
						return __hr;
					}
					return __object.IsEqual(pFont, pValue);
				}
				catch (Exception ex)
				{
					return (winmdroot.Foundation.HRESULT)ex.HResult;
				}
			}

			/// <summary>Determines whether this text font object has the same properties as the specified text font object. (ITextFont.IsEqual)</summary>
			/// <param name="pFont">
			/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/api/tom/nn-tom-itextfont">ITextFont</a>*</b> The text font object to compare against.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-isequal#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A variable that is <b>tomTrue</b> if the font objects have the same properties or <b>tomFalse</b> if they do not. This parameter can be <b>NULL</b>.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-isequal#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the text font objects have the same properties, the method succeeds and returns <b>S_OK</b>. If the text font objects do not have the same properties, the method fails and returns <b>S_FALSE</b>. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>.</para>
			/// </returns>
			/// <remarks>The text font objects are equal only if <i>pFont</i> belongs to the same Text Object Model (TOM) object as the current font object. The <b>ITextFont::IsEqual</b> method ignores entries for which either font object has an <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomUndefined</a>.</remarks>
			public unsafe void IsEqual([Optional] winmdroot.UI.Controls.RichEdit.ITextFont* pFont, int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,winmdroot.UI.Controls.RichEdit.ITextFont* ,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[10])((ITextFont*)Unsafe.AsPointer(ref this), pFont, pValue).ThrowOnFailure();
			}

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

			/// <summary>Resets the character formatting to the specified values.</summary>
			/// <param name="Value">Type: <b>long</b></param>
			/// <returns>
			/// <para>Type: <b><a href="https://docs.microsoft.com/windows/desktop/WinProg/windows-data-types">HRESULT</a></b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para>Calling <b>ITextFont::Reset</b> with <b>tomUndefined</b> sets all properties to undefined values. Thus, applying the font object to a range changes nothing. This applies to a font object that is obtained by the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextfont-getduplicate">ITextFont::GetDuplicate</a> method.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-reset#">Read more on docs.microsoft.com</see>.</para>
			/// </remarks>
			public void Reset(winmdroot.UI.Controls.RichEdit.tomConstants Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,winmdroot.UI.Controls.RichEdit.tomConstants ,winmdroot.Foundation.HRESULT>)lpVtbl[11])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetStyle(int*)"/>
			internal unsafe void GetStyle(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetStyle(pValueLocal);
				}
			}

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

			/// <summary>Gets the character style handle of the characters in a range.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> The character style handle.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getstyle#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>The Text Object Model (TOM) version 1.0 does not specify the meanings of the style handles. The meanings depend on other facilities of the text system that implements TOM.</remarks>
			public unsafe void GetStyle(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[12])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the character style handle of the characters in a range.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> The new character style handle.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setstyle#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>The Text Object Model (TOM) version 1.0 does not specify the meanings of the style handles. The meanings depend on other facilities of the text system that implements TOM.</remarks>
			public void SetStyle(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[13])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetAllCaps(int*)"/>
			internal unsafe void GetAllCaps(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetAllCaps(pValueLocal);
				}
			}

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

			/// <summary>Gets whether the characters are all uppercase.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getallcaps#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_ALLCAPS</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetAllCaps(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[14])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether the characters are all uppercase.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setallcaps#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setallcaps">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetAllCaps(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[15])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetAnimation(int*)"/>
			internal unsafe void GetAnimation(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetAnimation(pValueLocal);
				}
			}

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

			/// <summary>Gets the animation type.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> One of the following animation types.</para>
			/// <para><a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomNoAnimation</a> <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomLasVegasLights</a> <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomBlinkingBackground</a> <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomSparkleText</a> <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomMarchingBlackAnts</a> <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomMarchingRedAnts</a> <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomShimmer</a> <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomWipeDown</a> <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomWipeRight</a></para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getanimation#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getanimation">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetAnimation(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[16])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the animation type.</summary>
			/// <param name="Value">Type: <b>long</b></param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns the following COM error code. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setanimation">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetAnimation(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[17])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetBackColor(int*)"/>
			internal unsafe void GetBackColor(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetBackColor(pValueLocal);
				}
			}

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

			/// <summary>Gets the text background (highlight) color.</summary>
			/// <param name="pValue">Type: <b>long*</b></param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getbackcolor">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetBackColor(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[18])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the background color.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> The new background color. It can be one of the following.</para>
			/// <para></para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setbackcolor#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setbackcolor">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetBackColor(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[19])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetBold(int*)"/>
			internal unsafe void GetBold(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetBold(pValueLocal);
				}
			}

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

			/// <summary>Gets whether the characters are bold.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getbold#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>You can use the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextfont-setweight">ITextFont::SetWeight</a> and <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextfont-getweight">ITextFont::GetWeight</a> methods to set or retrieve the font weight more precisely than the <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextfont-setbold">ITextFont::SetBold</a> and <b>ITextFont::GetBold</b> methods.</remarks>
			public unsafe void GetBold(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[20])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are bold.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setbold#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setbold">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetBold(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[21])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetEmboss(int*)"/>
			internal unsafe void GetEmboss(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetEmboss(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are embossed.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getemboss#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_EMBOSS</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetEmboss(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[22])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are embossed.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setemboss#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setemboss">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetEmboss(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[23])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetForeColor(int*)"/>
			internal unsafe void GetForeColor(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetForeColor(pValueLocal);
				}
			}

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

			/// <summary>Gets the foreground, or text, color.</summary>
			/// <param name="pValue">Type: <b>long*</b></param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getforecolor">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetForeColor(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[24])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the foreground (text) color.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> The new foreground color. It can be one of the following.</para>
			/// <para></para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setforecolor#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setforecolor">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetForeColor(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[25])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetHidden(int*)"/>
			internal unsafe void GetHidden(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetHidden(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are hidden.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-gethidden#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_HIDDEN</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetHidden(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[26])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are hidden.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-sethidden#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-sethidden">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetHidden(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[27])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetEngrave(int*)"/>
			internal unsafe void GetEngrave(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetEngrave(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are displayed as imprinted characters.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getengrave#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_IMPRINT</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetEngrave(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[28])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are displayed as imprinted characters.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setengrave#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setengrave">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetEngrave(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[29])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetItalic(int*)"/>
			internal unsafe void GetItalic(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetItalic(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are in italics.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getitalic#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getitalic">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetItalic(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[30])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are in italics.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setitalic#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setitalic">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetItalic(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[31])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetKerning(float*)"/>
			internal unsafe void GetKerning(out float pValue)
			{
				fixed (float* pValueLocal = &pValue)
				{
					this.GetKerning(pValueLocal);
				}
			}

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

			/// <summary>Gets the minimum font size at which kerning occurs.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>float*</b> The minimum font size at which kerning occurs, in floating-point points.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getkerning#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para>If the value pointed to by <i>pValue</i> is zero, kerning is off. Positive values turn on pair kerning for font point sizes greater than or equal to the kerning value. For example, the value 1 turns on kerning for all legible sizes, whereas 16 turns on kerning only for font sizes of 16 points and larger.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getkerning#">Read more on docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetKerning(float* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[32])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the minimum font size at which kerning occurs.</summary>
			/// <param name="Value">
			/// <para>Type: <b>float</b> The new value of the minimum kerning size, in floating-point points.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setkerning#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>If this value is zero, kerning is turned off. Positive values turn on pair kerning for font sizes greater than this kerning value. For example, the value 1 turns on kerning for all legible sizes, whereas 16 turns on kerning only for font sizes of 16 points and larger.</remarks>
			public void SetKerning(float Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[33])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetLanguageID(int*)"/>
			internal unsafe void GetLanguageID(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetLanguageID(pValueLocal);
				}
			}

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

			/// <summary>Gets the language ID or language code identifier (LCID).</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> The language ID or LCID. The low word contains the language identifier. The high word is either zero or it contains the high word of the LCID. To retrieve the language identifier, mask out the high word. For more information, see <a href="https://docs.microsoft.com/windows/desktop/Intl/locale-identifiers">Locale Identifiers</a>.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getlanguageid#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>To get the BCP-47 language tag, such as "en-US", call <c>ITextRange2::GetText2(pBstr, tomLanguageTag)</c>, where <i>pBstr</i> specifies the desired language tag.</remarks>
			public unsafe void GetLanguageID(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[34])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the language ID or language code identifier (LCID).</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> The new language identifier. The low word contains the language identifier. The high word is either zero or it contains the high word of the locale identifier LCID. For more information, see <a href="https://docs.microsoft.com/windows/desktop/Intl/locale-identifiers">Locale Identifiers</a>.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setlanguageid#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para>If the high nibble of  <i>Value</i> is <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomCharset</a>, set the <i>charrep</i> from the <i>charset</i> in the low byte and the pitch and family from the next byte. See also <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextfont2-setcharrep">ITextFont2::SetCharRep</a>. If the high nibble of <i>Value</i> is <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomCharRepFromLcid</a>, set the <i>charrep</i> from the LCID and set the LCID as well. See <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextfont-getlanguageid">ITextFont::GetLanguageID</a> for more information.</para>
			/// <para>To set the BCP-47 language tag, such as "en-US", call <a href="https://docs.microsoft.com/windows/desktop/api/tom/nf-tom-itextrange2-settext2">ITextRange2::SetText2</a> and set the <a href="https://docs.microsoft.com/windows/win32/api/tom/ne-tom-tomconstants">tomLanguageTag</a> and <i>bstr</i> with the language tag.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setlanguageid#">Read more on docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetLanguageID(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[35])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

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

			/// <summary>Gets the font name.</summary>
			/// <param name="pbstr">
			/// <para>Type: <b>BSTR*</b> The font name.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getname#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getname">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetName(winmdroot.Foundation.BSTR* pbstr)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,winmdroot.Foundation.BSTR* ,winmdroot.Foundation.HRESULT>)lpVtbl[36])((ITextFont*)Unsafe.AsPointer(ref this), pbstr).ThrowOnFailure();
			}

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

			/// <summary>Sets the font name.</summary>
			/// <param name="bstr">
			/// <para>Type: <b>BSTR</b> The new font name.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setname#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setname">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetName(winmdroot.Foundation.BSTR bstr)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,winmdroot.Foundation.BSTR ,winmdroot.Foundation.HRESULT>)lpVtbl[37])((ITextFont*)Unsafe.AsPointer(ref this), bstr).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetOutline(int*)"/>
			internal unsafe void GetOutline(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetOutline(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are displayed as outlined characters.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getoutline#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_OUTLINE</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetOutline(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[38])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are displayed as outlined characters.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setoutline#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setoutline">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetOutline(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[39])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetPosition(float*)"/>
			internal unsafe void GetPosition(out float pValue)
			{
				fixed (float* pValueLocal = &pValue)
				{
					this.GetPosition(pValueLocal);
				}
			}

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

			/// <summary>Gets the amount that characters are offset vertically relative to the baseline.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>float*</b> The amount of vertical offset, in floating-point points.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getposition#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>Displayed text typically has a zero value for this property. Positive values raise the text, and negative values lower it.</remarks>
			public unsafe void GetPosition(float* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[40])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the amount that characters are offset vertically relative to the baseline.</summary>
			/// <param name="Value">
			/// <para>Type: <b>float</b> The new amount of vertical offset, in floating-point points.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setposition#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>Displayed text typically has a zero value for this property. Positive values raise the text, and negative values lower it.</remarks>
			public void SetPosition(float Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[41])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetProtected(int*)"/>
			internal unsafe void GetProtected(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetProtected(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are protected against attempts to modify them.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getprotected#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>In general, Text Object Model (TOM) methods that attempt to change the formatting or content of a range fail with <b>E_ACCESSDENIED</b> if any part of that range is protected, or if the document is read only. To make a change in protected text, the TOM client should attempt to turn off the protection of the text to be modified. The owner of the document may permit this to happen. For example in rich edit controls, attempts to change protected text result in an <a href="https://docs.microsoft.com/windows/desktop/Controls/en-protected">EN_PROTECTED</a> notification code to the creator of the document, who then can refuse or grant permission for the change. The creator is the client that created a windowed rich edit control through the <a href="https://docs.microsoft.com/windows/desktop/api/winuser/nf-winuser-createwindowa">CreateWindow</a> function or the <a href="https://docs.microsoft.com/windows/desktop/api/textserv/nl-textserv-itexthost">ITextHost</a> object that called the <a href="https://docs.microsoft.com/windows/desktop/api/textserv/nf-textserv-createtextservices">CreateTextServices</a> function to create a windowless rich edit control.</remarks>
			public unsafe void GetProtected(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[42])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are protected against attempts to modify them.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setprotected#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>In general, Text Object Model (TOM) methods that attempt to change the formatting or content of a range will fail with <b>E_ACCESSDENIED</b> if any part of that range is protected or if the document is read-only. To make a change in protected text, the TOM client should attempt to turn off the protection of the text to be modified. The owner of the document may permit this to happen. For example in rich edit controls, attempts to change protected text result in an <a href="https://docs.microsoft.com/windows/desktop/Controls/en-protected">EN_PROTECTED</a> notification code to the creator of the document, who then can refuse or grant permission for the change. The creator is the client that created a windowed rich-edit control through the <a href="https://docs.microsoft.com/windows/desktop/api/winuser/nf-winuser-createwindowa">CreateWindow</a> function or the <a href="https://docs.microsoft.com/windows/desktop/api/textserv/nl-textserv-itexthost">ITextHost</a> object that called the <a href="https://docs.microsoft.com/windows/desktop/api/textserv/nf-textserv-createtextservices">CreateTextServices</a> function to create a windowless rich edit control.</remarks>
			public void SetProtected(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[43])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetShadow(int*)"/>
			internal unsafe void GetShadow(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetShadow(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are displayed as shadowed characters.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getshadow#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_SHADOW</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetShadow(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[44])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are displayed as shadowed characters.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setshadow#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setshadow">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetShadow(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[45])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetSize(float*)"/>
			internal unsafe void GetSize(out float pValue)
			{
				fixed (float* pValueLocal = &pValue)
				{
					this.GetSize(pValueLocal);
				}
			}

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

			/// <summary>Gets the font size. (ITextFont.GetSize)</summary>
			/// <param name="pValue">
			/// <para>Type: <b>float*</b> The font size, in floating-point points.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getsize#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getsize">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetSize(float* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[46])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the font size.</summary>
			/// <param name="Value">
			/// <para>Type: <b>float</b> The new font size, in floating-point points.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setsize#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setsize">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetSize(float Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[47])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetSmallCaps(int*)"/>
			internal unsafe void GetSmallCaps(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetSmallCaps(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are in small capital letters.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getsmallcaps#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_SMALLCAPS</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetSmallCaps(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[48])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are in small capital letters.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setsmallcaps#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setsmallcaps">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetSmallCaps(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[49])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetSpacing(float*)"/>
			internal unsafe void GetSpacing(out float pValue)
			{
				fixed (float* pValueLocal = &pValue)
				{
					this.GetSpacing(pValueLocal);
				}
			}

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

			/// <summary>Gets the amount of horizontal spacing between characters.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>float*</b> The amount of horizontal spacing between characters, in floating-point points.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getspacing#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>Displayed text typically has an intercharacter spacing value of zero. Positive values expand the spacing, and negative values compress it.</remarks>
			public unsafe void GetSpacing(float* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,float* ,winmdroot.Foundation.HRESULT>)lpVtbl[50])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the amount of horizontal spacing between characters.</summary>
			/// <param name="Value">
			/// <para>Type: <b>float</b> The new amount of horizontal spacing between characters, in floating-point points.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setspacing#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>Displayed text typically has an intercharacter spacing value of zero. Positive values expand the spacing, and negative values compress it.</remarks>
			public void SetSpacing(float Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,float ,winmdroot.Foundation.HRESULT>)lpVtbl[51])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetStrikeThrough(int*)"/>
			internal unsafe void GetStrikeThrough(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetStrikeThrough(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are displayed with a horizontal line through the center.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getstrikethrough#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_STRIKEOUT</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetStrikeThrough(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[52])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are displayed with a horizontal line through the center.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setstrikethrough#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setstrikethrough">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetStrikeThrough(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[53])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetSubscript(int*)"/>
			internal unsafe void GetSubscript(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetSubscript(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are displayed as subscript.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getsubscript#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_SUBSCRIPT</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetSubscript(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[54])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are displayed as subscript.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setsubscript#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setsubscript">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetSubscript(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[55])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetSuperscript(int*)"/>
			internal unsafe void GetSuperscript(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetSuperscript(pValueLocal);
				}
			}

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

			/// <summary>Gets whether characters are displayed as superscript.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getsuperscript#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>This property corresponds to the <b>CFE_SUPERSCRIPT</b> effect described in the <a href="https://docs.microsoft.com/windows/desktop/api/richedit/ns-richedit-charformat2a">CHARFORMAT2</a> structure.</remarks>
			public unsafe void GetSuperscript(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[56])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets whether characters are displayed as superscript.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> A <a href="https://docs.microsoft.com/windows/desktop/Controls/about-text-object-model">tomBool</a> value that can be one of the following. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setsuperscript#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setsuperscript">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetSuperscript(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[57])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetUnderline(int*)"/>
			internal unsafe void GetUnderline(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetUnderline(pValueLocal);
				}
			}

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

			/// <summary>Gets the type of underlining for the characters in a range.</summary>
			/// <param name="pValue">Type: <b>long*</b></param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getunderline">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetUnderline(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[58])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the type of underlining for the characters in a range.</summary>
			/// <param name="Value">Type: <b>long</b></param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setunderline">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetUnderline(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[59])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

			/// <inheritdoc cref="GetWeight(int*)"/>
			internal unsafe void GetWeight(out int pValue)
			{
				fixed (int* pValueLocal = &pValue)
				{
					this.GetWeight(pValueLocal);
				}
			}

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

			/// <summary>Gets the font weight for the characters in a range.</summary>
			/// <param name="pValue">
			/// <para>Type: <b>long*</b> The font weight. The Bold property is a binary version of the Weight property that sets the weight to <b>FW_BOLD</b>. The font weight exists in the <a href="https://docs.microsoft.com/windows/desktop/api/wingdi/ns-wingdi-logfonta">LOGFONT</a> structure and the <a href="https://docs.microsoft.com/windows/desktop/api/ocidl/nn-ocidl-ifont">IFont</a> interface. Windows defines the following degrees of font weight. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getweight#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes. For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-getweight">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public unsafe void GetWeight(int* pValue)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int* ,winmdroot.Foundation.HRESULT>)lpVtbl[60])((ITextFont*)Unsafe.AsPointer(ref this), pValue).ThrowOnFailure();
			}

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

			/// <summary>Sets the font weight for the characters in a range.</summary>
			/// <param name="Value">
			/// <para>Type: <b>long</b> The new font weight. The Bold property is a binary version of the Weight property that sets the weight to <b>FW_BOLD</b>. The font weight exists in the <a href="https://docs.microsoft.com/windows/desktop/api/wingdi/ns-wingdi-logfonta">LOGFONT</a> structure and the <a href="https://docs.microsoft.com/windows/desktop/api/ocidl/nn-ocidl-ifont">IFont</a> interface. Windows defines the following degrees of font weight. </para>
			/// <para>This doc was truncated.</para>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setweight#parameters">Read more on docs.microsoft.com</see>.</para>
			/// </param>
			/// <returns>
			/// <para>Type: <b>HRESULT</b> If the method succeeds, it returns <b>S_OK</b>. If the method fails, it returns one of the following COM error codes.  For more information about COM error codes, see <a href="https://docs.microsoft.com/windows/desktop/com/error-handling-in-com">Error Handling in COM</a>. </para>
			/// <para>This doc was truncated.</para>
			/// </returns>
			/// <remarks>
			/// <para><see href="https://learn.microsoft.com/windows/win32/api/tom/nf-tom-itextfont-setweight">Learn more about this API from docs.microsoft.com</see>.</para>
			/// </remarks>
			public void SetWeight(int Value)
			{
				((delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT>)lpVtbl[61])((ITextFont*)Unsafe.AsPointer(ref this), Value).ThrowOnFailure();
			}

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

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

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

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

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

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

				internal delegate *unmanaged [Stdcall]<ITextFont*,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]<ITextFont*,winmdroot.UI.Controls.RichEdit.ITextFont** ,winmdroot.Foundation.HRESULT> GetDuplicate_8;

				internal delegate *unmanaged [Stdcall]<ITextFont*,winmdroot.UI.Controls.RichEdit.ITextFont* ,winmdroot.Foundation.HRESULT> SetDuplicate_9;

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

				internal delegate *unmanaged [Stdcall]<ITextFont*,winmdroot.UI.Controls.RichEdit.ITextFont* ,int* ,winmdroot.Foundation.HRESULT> IsEqual_11;

				internal delegate *unmanaged [Stdcall]<ITextFont*,winmdroot.UI.Controls.RichEdit.tomConstants ,winmdroot.Foundation.HRESULT> Reset_12;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

				internal delegate *unmanaged [Stdcall]<ITextFont*,int ,winmdroot.Foundation.HRESULT> SetWeight_62;
			} 
			public static void PopulateVTable(Vtbl* vtable)
			{
				vtable->GetDuplicate_8 = &GetDuplicate;
				vtable->SetDuplicate_9 = &SetDuplicate;
				vtable->CanChange_10 = &CanChange;
				vtable->IsEqual_11 = &IsEqual;
				vtable->Reset_12 = &Reset;
				vtable->GetStyle_13 = &GetStyle;
				vtable->SetStyle_14 = &SetStyle;
				vtable->GetAllCaps_15 = &GetAllCaps;
				vtable->SetAllCaps_16 = &SetAllCaps;
				vtable->GetAnimation_17 = &GetAnimation;
				vtable->SetAnimation_18 = &SetAnimation;
				vtable->GetBackColor_19 = &GetBackColor;
				vtable->SetBackColor_20 = &SetBackColor;
				vtable->GetBold_21 = &GetBold;
				vtable->SetBold_22 = &SetBold;
				vtable->GetEmboss_23 = &GetEmboss;
				vtable->SetEmboss_24 = &SetEmboss;
				vtable->GetForeColor_25 = &GetForeColor;
				vtable->SetForeColor_26 = &SetForeColor;
				vtable->GetHidden_27 = &GetHidden;
				vtable->SetHidden_28 = &SetHidden;
				vtable->GetEngrave_29 = &GetEngrave;
				vtable->SetEngrave_30 = &SetEngrave;
				vtable->GetItalic_31 = &GetItalic;
				vtable->SetItalic_32 = &SetItalic;
				vtable->GetKerning_33 = &GetKerning;
				vtable->SetKerning_34 = &SetKerning;
				vtable->GetLanguageID_35 = &GetLanguageID;
				vtable->SetLanguageID_36 = &SetLanguageID;
				vtable->GetName_37 = &GetName;
				vtable->SetName_38 = &SetName;
				vtable->GetOutline_39 = &GetOutline;
				vtable->SetOutline_40 = &SetOutline;
				vtable->GetPosition_41 = &GetPosition;
				vtable->SetPosition_42 = &SetPosition;
				vtable->GetProtected_43 = &GetProtected;
				vtable->SetProtected_44 = &SetProtected;
				vtable->GetShadow_45 = &GetShadow;
				vtable->SetShadow_46 = &SetShadow;
				vtable->GetSize_47 = &GetSize;
				vtable->SetSize_48 = &SetSize;
				vtable->GetSmallCaps_49 = &GetSmallCaps;
				vtable->SetSmallCaps_50 = &SetSmallCaps;
				vtable->GetSpacing_51 = &GetSpacing;
				vtable->SetSpacing_52 = &SetSpacing;
				vtable->GetStrikeThrough_53 = &GetStrikeThrough;
				vtable->SetStrikeThrough_54 = &SetStrikeThrough;
				vtable->GetSubscript_55 = &GetSubscript;
				vtable->SetSubscript_56 = &SetSubscript;
				vtable->GetSuperscript_57 = &GetSuperscript;
				vtable->SetSuperscript_58 = &SetSuperscript;
				vtable->GetUnderline_59 = &GetUnderline;
				vtable->SetUnderline_60 = &SetUnderline;
				vtable->GetWeight_61 = &GetWeight;
				vtable->SetWeight_62 = &SetWeight;
			}

			private void** lpVtbl;

			/// <summary>The IID guid for this interface.</summary>
			/// <value>{8cc497c3-a1df-11ce-8098-00aa0047be5d}</value>
			internal static readonly Guid IID_Guid = new Guid(0x8CC497C3, 0xA1DF, 0x11CE, 0x80, 0x98, 0x00, 0xAA, 0x00, 0x47, 0xBE, 0x5D);

			static ref readonly Guid IComIID.Guid			{
								[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
				{
					ReadOnlySpan<byte> data = new byte[]					{
0xC3,0x97,0xC4,0x8C,0xDF,0xA1,0xCE,0x11,0x80,0x98,0x00,0xAA,0x00,0x47,0xBE,0x5D					};
					return ref Unsafe.As<byte,Guid>(ref MemoryMarshal.GetReference(data));
				}
			}
			[Guid("8CC497C3-A1DF-11CE-8098-00AA0047BE5D"),InterfaceType(ComInterfaceType.InterfaceIsDual),ComImport()]
			[SupportedOSPlatform("windows6.0.6000")]
			internal interface Interface
			{
				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetDuplicate(winmdroot.UI.Controls.RichEdit.ITextFont** ppFont);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT SetDuplicate([Optional] winmdroot.UI.Controls.RichEdit.ITextFont* pFont);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT CanChange(int* pValue);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT IsEqual([Optional] winmdroot.UI.Controls.RichEdit.ITextFont* pFont, int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT Reset(winmdroot.UI.Controls.RichEdit.tomConstants Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetStyle(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetStyle(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetAllCaps(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetAllCaps(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetAnimation(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetAnimation(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetBackColor(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetBackColor(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetBold(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetBold(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetEmboss(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetEmboss(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetForeColor(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetForeColor(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetHidden(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetHidden(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetEngrave(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetEngrave(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetItalic(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetItalic(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetKerning(float* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetKerning(float Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetLanguageID(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetLanguageID(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetName(winmdroot.Foundation.BSTR* pbstr);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetName(winmdroot.Foundation.BSTR bstr);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetOutline(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetOutline(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetPosition(float* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetPosition(float Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetProtected(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetProtected(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetShadow(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetShadow(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetSize(float* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetSize(float Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetSmallCaps(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetSmallCaps(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetSpacing(float* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetSpacing(float Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetStrikeThrough(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetStrikeThrough(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetSubscript(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetSubscript(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetSuperscript(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetSuperscript(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetUnderline(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetUnderline(int Value);

				[PreserveSig()]
				unsafe winmdroot.Foundation.HRESULT GetWeight(int* pValue);

								[PreserveSig()]
winmdroot.Foundation.HRESULT SetWeight(int Value);
			}
		}
	}
}