// ------------------------------------------------------------------------------
// <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>
// ------------------------------------------------------------------------------

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using HexaGen.Runtime;
using System.Numerics;

namespace Dalamud.Bindings.ImGui
{
	public unsafe partial class ImGui
	{

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTable(string strId, int column, Vector2 outerSize, float innerWidth)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (strId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(strId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(strId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginTableNative(pStr0, column, (ImGuiTableFlags)(0), outerSize, innerWidth);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EndTableNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[262])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[262])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void EndTable()
		{
			EndTableNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TableNextRowNative(ImGuiTableRowFlags rowFlags, float minRowHeight)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiTableRowFlags, float, void>)funcTable[263])(rowFlags, minRowHeight);
			#else
			((delegate* unmanaged[Cdecl]<ImGuiTableRowFlags, float, void>)funcTable[263])(rowFlags, minRowHeight);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableNextRow(ImGuiTableRowFlags rowFlags, float minRowHeight)
		{
			TableNextRowNative(rowFlags, minRowHeight);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableNextRow(ImGuiTableRowFlags rowFlags)
		{
			TableNextRowNative(rowFlags, (float)(0.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableNextRow()
		{
			TableNextRowNative((ImGuiTableRowFlags)(0), (float)(0.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableNextRow(float minRowHeight)
		{
			TableNextRowNative((ImGuiTableRowFlags)(0), minRowHeight);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte TableNextColumnNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[264])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[264])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TableNextColumn()
		{
			byte ret = TableNextColumnNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte TableSetColumnIndexNative(int columnN)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, byte>)funcTable[265])(columnN);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<int, byte>)funcTable[265])(columnN);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TableSetColumnIndex(int columnN)
		{
			byte ret = TableSetColumnIndexNative(columnN);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TableSetupColumnNative(byte* label, ImGuiTableColumnFlags flags, float initWidthOrWeight, uint userId)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte*, ImGuiTableColumnFlags, float, uint, void>)funcTable[266])(label, flags, initWidthOrWeight, userId);
			#else
			((delegate* unmanaged[Cdecl]<nint, ImGuiTableColumnFlags, float, uint, void>)funcTable[266])((nint)label, flags, initWidthOrWeight, userId);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(byte* label, ImGuiTableColumnFlags flags, float initWidthOrWeight, uint userId)
		{
			TableSetupColumnNative(label, flags, initWidthOrWeight, userId);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(byte* label, ImGuiTableColumnFlags flags, float initWidthOrWeight)
		{
			TableSetupColumnNative(label, flags, initWidthOrWeight, (uint)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(byte* label, ImGuiTableColumnFlags flags)
		{
			TableSetupColumnNative(label, flags, (float)(0.0f), (uint)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(byte* label)
		{
			TableSetupColumnNative(label, (ImGuiTableColumnFlags)(0), (float)(0.0f), (uint)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(byte* label, float initWidthOrWeight)
		{
			TableSetupColumnNative(label, (ImGuiTableColumnFlags)(0), initWidthOrWeight, (uint)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(byte* label, ImGuiTableColumnFlags flags, uint userId)
		{
			TableSetupColumnNative(label, flags, (float)(0.0f), userId);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(byte* label, uint userId)
		{
			TableSetupColumnNative(label, (ImGuiTableColumnFlags)(0), (float)(0.0f), userId);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(byte* label, float initWidthOrWeight, uint userId)
		{
			TableSetupColumnNative(label, (ImGuiTableColumnFlags)(0), initWidthOrWeight, userId);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ref byte label, ImGuiTableColumnFlags flags, float initWidthOrWeight, uint userId)
		{
			fixed (byte* plabel = &label)
			{
				TableSetupColumnNative((byte*)plabel, flags, initWidthOrWeight, userId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ref byte label, ImGuiTableColumnFlags flags, float initWidthOrWeight)
		{
			fixed (byte* plabel = &label)
			{
				TableSetupColumnNative((byte*)plabel, flags, initWidthOrWeight, (uint)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ref byte label, ImGuiTableColumnFlags flags)
		{
			fixed (byte* plabel = &label)
			{
				TableSetupColumnNative((byte*)plabel, flags, (float)(0.0f), (uint)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ref byte label)
		{
			fixed (byte* plabel = &label)
			{
				TableSetupColumnNative((byte*)plabel, (ImGuiTableColumnFlags)(0), (float)(0.0f), (uint)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ref byte label, float initWidthOrWeight)
		{
			fixed (byte* plabel = &label)
			{
				TableSetupColumnNative((byte*)plabel, (ImGuiTableColumnFlags)(0), initWidthOrWeight, (uint)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ref byte label, ImGuiTableColumnFlags flags, uint userId)
		{
			fixed (byte* plabel = &label)
			{
				TableSetupColumnNative((byte*)plabel, flags, (float)(0.0f), userId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ref byte label, uint userId)
		{
			fixed (byte* plabel = &label)
			{
				TableSetupColumnNative((byte*)plabel, (ImGuiTableColumnFlags)(0), (float)(0.0f), userId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ref byte label, float initWidthOrWeight, uint userId)
		{
			fixed (byte* plabel = &label)
			{
				TableSetupColumnNative((byte*)plabel, (ImGuiTableColumnFlags)(0), initWidthOrWeight, userId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ReadOnlySpan<byte> label, ImGuiTableColumnFlags flags, float initWidthOrWeight, uint userId)
		{
			fixed (byte* plabel = label)
			{
				TableSetupColumnNative((byte*)plabel, flags, initWidthOrWeight, userId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ReadOnlySpan<byte> label, ImGuiTableColumnFlags flags, float initWidthOrWeight)
		{
			fixed (byte* plabel = label)
			{
				TableSetupColumnNative((byte*)plabel, flags, initWidthOrWeight, (uint)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ReadOnlySpan<byte> label, ImGuiTableColumnFlags flags)
		{
			fixed (byte* plabel = label)
			{
				TableSetupColumnNative((byte*)plabel, flags, (float)(0.0f), (uint)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ReadOnlySpan<byte> label)
		{
			fixed (byte* plabel = label)
			{
				TableSetupColumnNative((byte*)plabel, (ImGuiTableColumnFlags)(0), (float)(0.0f), (uint)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ReadOnlySpan<byte> label, float initWidthOrWeight)
		{
			fixed (byte* plabel = label)
			{
				TableSetupColumnNative((byte*)plabel, (ImGuiTableColumnFlags)(0), initWidthOrWeight, (uint)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ReadOnlySpan<byte> label, ImGuiTableColumnFlags flags, uint userId)
		{
			fixed (byte* plabel = label)
			{
				TableSetupColumnNative((byte*)plabel, flags, (float)(0.0f), userId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ReadOnlySpan<byte> label, uint userId)
		{
			fixed (byte* plabel = label)
			{
				TableSetupColumnNative((byte*)plabel, (ImGuiTableColumnFlags)(0), (float)(0.0f), userId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(ReadOnlySpan<byte> label, float initWidthOrWeight, uint userId)
		{
			fixed (byte* plabel = label)
			{
				TableSetupColumnNative((byte*)plabel, (ImGuiTableColumnFlags)(0), initWidthOrWeight, userId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float initWidthOrWeight, uint userId)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			TableSetupColumnNative(pStr0, flags, initWidthOrWeight, userId);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float initWidthOrWeight)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			TableSetupColumnNative(pStr0, flags, initWidthOrWeight, (uint)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			TableSetupColumnNative(pStr0, flags, (float)(0.0f), (uint)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(string label)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			TableSetupColumnNative(pStr0, (ImGuiTableColumnFlags)(0), (float)(0.0f), (uint)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(string label, float initWidthOrWeight)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			TableSetupColumnNative(pStr0, (ImGuiTableColumnFlags)(0), initWidthOrWeight, (uint)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, uint userId)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			TableSetupColumnNative(pStr0, flags, (float)(0.0f), userId);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(string label, uint userId)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			TableSetupColumnNative(pStr0, (ImGuiTableColumnFlags)(0), (float)(0.0f), userId);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupColumn(string label, float initWidthOrWeight, uint userId)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			TableSetupColumnNative(pStr0, (ImGuiTableColumnFlags)(0), initWidthOrWeight, userId);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TableSetupScrollFreezeNative(int cols, int rows)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int, int, void>)funcTable[267])(cols, rows);
			#else
			((delegate* unmanaged[Cdecl]<int, int, void>)funcTable[267])(cols, rows);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetupScrollFreeze(int cols, int rows)
		{
			TableSetupScrollFreezeNative(cols, rows);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TableHeadersRowNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[268])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[268])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableHeadersRow()
		{
			TableHeadersRowNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TableHeaderNative(byte* label)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte*, void>)funcTable[269])(label);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[269])((nint)label);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableHeader(byte* label)
		{
			TableHeaderNative(label);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableHeader(ref byte label)
		{
			fixed (byte* plabel = &label)
			{
				TableHeaderNative((byte*)plabel);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableHeader(ReadOnlySpan<byte> label)
		{
			fixed (byte* plabel = label)
			{
				TableHeaderNative((byte*)plabel);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableHeader(string label)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			TableHeaderNative(pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiTableSortSpecs* TableGetSortSpecsNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiTableSortSpecs*>)funcTable[270])();
			#else
			return (ImGuiTableSortSpecs*)((delegate* unmanaged[Cdecl]<nint>)funcTable[270])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiTableSortSpecsPtr TableGetSortSpecs()
		{
			ImGuiTableSortSpecsPtr ret = TableGetSortSpecsNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int TableGetColumnCountNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int>)funcTable[271])();
			#else
			return (int)((delegate* unmanaged[Cdecl]<int>)funcTable[271])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int TableGetColumnCount()
		{
			int ret = TableGetColumnCountNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int TableGetColumnIndexNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int>)funcTable[272])();
			#else
			return (int)((delegate* unmanaged[Cdecl]<int>)funcTable[272])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int TableGetColumnIndex()
		{
			int ret = TableGetColumnIndexNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int TableGetRowIndexNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int>)funcTable[273])();
			#else
			return (int)((delegate* unmanaged[Cdecl]<int>)funcTable[273])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int TableGetRowIndex()
		{
			int ret = TableGetRowIndexNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte* TableGetColumnNameNative(int columnN)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, byte*>)funcTable[274])(columnN);
			#else
			return (byte*)((delegate* unmanaged[Cdecl]<int, nint>)funcTable[274])(columnN);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte* TableGetColumnName(int columnN)
		{
			byte* ret = TableGetColumnNameNative(columnN);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte* TableGetColumnName()
		{
			byte* ret = TableGetColumnNameNative((int)(-1));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static string TableGetColumnNameS()
		{
			string ret = Utils.DecodeStringUTF8(TableGetColumnNameNative((int)(-1)));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static string TableGetColumnNameS(int columnN)
		{
			string ret = Utils.DecodeStringUTF8(TableGetColumnNameNative(columnN));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiTableColumnFlags TableGetColumnFlagsNative(int columnN)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, ImGuiTableColumnFlags>)funcTable[275])(columnN);
			#else
			return (ImGuiTableColumnFlags)((delegate* unmanaged[Cdecl]<int, ImGuiTableColumnFlags>)funcTable[275])(columnN);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiTableColumnFlags TableGetColumnFlags(int columnN)
		{
			ImGuiTableColumnFlags ret = TableGetColumnFlagsNative(columnN);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiTableColumnFlags TableGetColumnFlags()
		{
			ImGuiTableColumnFlags ret = TableGetColumnFlagsNative((int)(-1));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TableSetColumnEnabledNative(int columnN, byte v)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int, byte, void>)funcTable[276])(columnN, v);
			#else
			((delegate* unmanaged[Cdecl]<int, byte, void>)funcTable[276])(columnN, v);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetColumnEnabled(int columnN, bool v)
		{
			TableSetColumnEnabledNative(columnN, v ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TableSetBgColorNative(ImGuiTableBgTarget target, uint color, int columnN)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiTableBgTarget, uint, int, void>)funcTable[277])(target, color, columnN);
			#else
			((delegate* unmanaged[Cdecl]<ImGuiTableBgTarget, uint, int, void>)funcTable[277])(target, color, columnN);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetBgColor(ImGuiTableBgTarget target, uint color, int columnN)
		{
			TableSetBgColorNative(target, color, columnN);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TableSetBgColor(ImGuiTableBgTarget target, uint color)
		{
			TableSetBgColorNative(target, color, (int)(-1));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ColumnsNative(int count, byte* id, byte border)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int, byte*, byte, void>)funcTable[278])(count, id, border);
			#else
			((delegate* unmanaged[Cdecl]<int, nint, byte, void>)funcTable[278])(count, (nint)id, border);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count, byte* id, bool border)
		{
			ColumnsNative(count, id, border ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count, byte* id)
		{
			ColumnsNative(count, id, (byte)(1));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count)
		{
			ColumnsNative(count, (byte*)(default), (byte)(1));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns()
		{
			ColumnsNative((int)(1), (byte*)(default), (byte)(1));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(byte* id)
		{
			ColumnsNative((int)(1), id, (byte)(1));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count, bool border)
		{
			ColumnsNative(count, (byte*)(default), border ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(bool border)
		{
			ColumnsNative((int)(1), (byte*)(default), border ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(byte* id, bool border)
		{
			ColumnsNative((int)(1), id, border ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count, ref byte id, bool border)
		{
			fixed (byte* pid = &id)
			{
				ColumnsNative(count, (byte*)pid, border ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count, ref byte id)
		{
			fixed (byte* pid = &id)
			{
				ColumnsNative(count, (byte*)pid, (byte)(1));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(ref byte id)
		{
			fixed (byte* pid = &id)
			{
				ColumnsNative((int)(1), (byte*)pid, (byte)(1));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(ref byte id, bool border)
		{
			fixed (byte* pid = &id)
			{
				ColumnsNative((int)(1), (byte*)pid, border ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count, ReadOnlySpan<byte> id, bool border)
		{
			fixed (byte* pid = id)
			{
				ColumnsNative(count, (byte*)pid, border ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count, ReadOnlySpan<byte> id)
		{
			fixed (byte* pid = id)
			{
				ColumnsNative(count, (byte*)pid, (byte)(1));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(ReadOnlySpan<byte> id)
		{
			fixed (byte* pid = id)
			{
				ColumnsNative((int)(1), (byte*)pid, (byte)(1));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(ReadOnlySpan<byte> id, bool border)
		{
			fixed (byte* pid = id)
			{
				ColumnsNative((int)(1), (byte*)pid, border ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count, string id, bool border)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (id != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(id);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(id, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			ColumnsNative(count, pStr0, border ? (byte)1 : (byte)0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(int count, string id)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (id != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(id);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(id, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			ColumnsNative(count, pStr0, (byte)(1));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(string id)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (id != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(id);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(id, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			ColumnsNative((int)(1), pStr0, (byte)(1));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Columns(string id, bool border)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (id != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(id);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(id, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			ColumnsNative((int)(1), pStr0, border ? (byte)1 : (byte)0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void NextColumnNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[279])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[279])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void NextColumn()
		{
			NextColumnNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetColumnIndexNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int>)funcTable[280])();
			#else
			return (int)((delegate* unmanaged[Cdecl]<int>)funcTable[280])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetColumnIndex()
		{
			int ret = GetColumnIndexNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float GetColumnWidthNative(int columnIndex)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, float>)funcTable[281])(columnIndex);
			#else
			return (float)((delegate* unmanaged[Cdecl]<int, float>)funcTable[281])(columnIndex);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetColumnWidth(int columnIndex)
		{
			float ret = GetColumnWidthNative(columnIndex);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetColumnWidth()
		{
			float ret = GetColumnWidthNative((int)(-1));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetColumnWidthNative(int columnIndex, float width)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int, float, void>)funcTable[282])(columnIndex, width);
			#else
			((delegate* unmanaged[Cdecl]<int, float, void>)funcTable[282])(columnIndex, width);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetColumnWidth(int columnIndex, float width)
		{
			SetColumnWidthNative(columnIndex, width);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float GetColumnOffsetNative(int columnIndex)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, float>)funcTable[283])(columnIndex);
			#else
			return (float)((delegate* unmanaged[Cdecl]<int, float>)funcTable[283])(columnIndex);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetColumnOffset(int columnIndex)
		{
			float ret = GetColumnOffsetNative(columnIndex);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetColumnOffset()
		{
			float ret = GetColumnOffsetNative((int)(-1));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetColumnOffsetNative(int columnIndex, float offsetX)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int, float, void>)funcTable[284])(columnIndex, offsetX);
			#else
			((delegate* unmanaged[Cdecl]<int, float, void>)funcTable[284])(columnIndex, offsetX);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetColumnOffset(int columnIndex, float offsetX)
		{
			SetColumnOffsetNative(columnIndex, offsetX);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetColumnsCountNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int>)funcTable[285])();
			#else
			return (int)((delegate* unmanaged[Cdecl]<int>)funcTable[285])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetColumnsCount()
		{
			int ret = GetColumnsCountNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte BeginTabBarNative(byte* strId, ImGuiTabBarFlags flags)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, ImGuiTabBarFlags, byte>)funcTable[286])(strId, flags);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, ImGuiTabBarFlags, byte>)funcTable[286])((nint)strId, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabBar(byte* strId, ImGuiTabBarFlags flags)
		{
			byte ret = BeginTabBarNative(strId, flags);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabBar(byte* strId)
		{
			byte ret = BeginTabBarNative(strId, (ImGuiTabBarFlags)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabBar(ref byte strId, ImGuiTabBarFlags flags)
		{
			fixed (byte* pstrId = &strId)
			{
				byte ret = BeginTabBarNative((byte*)pstrId, flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabBar(ref byte strId)
		{
			fixed (byte* pstrId = &strId)
			{
				byte ret = BeginTabBarNative((byte*)pstrId, (ImGuiTabBarFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabBar(ReadOnlySpan<byte> strId, ImGuiTabBarFlags flags)
		{
			fixed (byte* pstrId = strId)
			{
				byte ret = BeginTabBarNative((byte*)pstrId, flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabBar(ReadOnlySpan<byte> strId)
		{
			fixed (byte* pstrId = strId)
			{
				byte ret = BeginTabBarNative((byte*)pstrId, (ImGuiTabBarFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabBar(string strId, ImGuiTabBarFlags flags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (strId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(strId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(strId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginTabBarNative(pStr0, flags);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabBar(string strId)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (strId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(strId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(strId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginTabBarNative(pStr0, (ImGuiTabBarFlags)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EndTabBarNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[287])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[287])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void EndTabBar()
		{
			EndTabBarNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte BeginTabItemNative(byte* label, bool* pOpen, ImGuiTabItemFlags flags)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, bool*, ImGuiTabItemFlags, byte>)funcTable[288])(label, pOpen, flags);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, nint, ImGuiTabItemFlags, byte>)funcTable[288])((nint)label, (nint)pOpen, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(byte* label, bool* pOpen, ImGuiTabItemFlags flags)
		{
			byte ret = BeginTabItemNative(label, pOpen, flags);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(byte* label, bool* pOpen)
		{
			byte ret = BeginTabItemNative(label, pOpen, (ImGuiTabItemFlags)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(byte* label)
		{
			byte ret = BeginTabItemNative(label, (bool*)(default), (ImGuiTabItemFlags)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(byte* label, ImGuiTabItemFlags flags)
		{
			byte ret = BeginTabItemNative(label, (bool*)(default), flags);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ref byte label, bool* pOpen, ImGuiTabItemFlags flags)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = BeginTabItemNative((byte*)plabel, pOpen, flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ref byte label, bool* pOpen)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = BeginTabItemNative((byte*)plabel, pOpen, (ImGuiTabItemFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ref byte label)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = BeginTabItemNative((byte*)plabel, (bool*)(default), (ImGuiTabItemFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ref byte label, ImGuiTabItemFlags flags)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = BeginTabItemNative((byte*)plabel, (bool*)(default), flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ReadOnlySpan<byte> label, bool* pOpen, ImGuiTabItemFlags flags)
		{
			fixed (byte* plabel = label)
			{
				byte ret = BeginTabItemNative((byte*)plabel, pOpen, flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ReadOnlySpan<byte> label, bool* pOpen)
		{
			fixed (byte* plabel = label)
			{
				byte ret = BeginTabItemNative((byte*)plabel, pOpen, (ImGuiTabItemFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ReadOnlySpan<byte> label)
		{
			fixed (byte* plabel = label)
			{
				byte ret = BeginTabItemNative((byte*)plabel, (bool*)(default), (ImGuiTabItemFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ReadOnlySpan<byte> label, ImGuiTabItemFlags flags)
		{
			fixed (byte* plabel = label)
			{
				byte ret = BeginTabItemNative((byte*)plabel, (bool*)(default), flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(string label, bool* pOpen, ImGuiTabItemFlags flags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginTabItemNative(pStr0, pOpen, flags);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(string label, bool* pOpen)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginTabItemNative(pStr0, pOpen, (ImGuiTabItemFlags)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(string label)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginTabItemNative(pStr0, (bool*)(default), (ImGuiTabItemFlags)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(string label, ImGuiTabItemFlags flags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginTabItemNative(pStr0, (bool*)(default), flags);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(byte* label, ref bool pOpen, ImGuiTabItemFlags flags)
		{
			fixed (bool* ppOpen = &pOpen)
			{
				byte ret = BeginTabItemNative(label, (bool*)ppOpen, flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(byte* label, ref bool pOpen)
		{
			fixed (bool* ppOpen = &pOpen)
			{
				byte ret = BeginTabItemNative(label, (bool*)ppOpen, (ImGuiTabItemFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ref byte label, ref bool pOpen, ImGuiTabItemFlags flags)
		{
			fixed (byte* plabel = &label)
			{
				fixed (bool* ppOpen = &pOpen)
				{
					byte ret = BeginTabItemNative((byte*)plabel, (bool*)ppOpen, flags);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ref byte label, ref bool pOpen)
		{
			fixed (byte* plabel = &label)
			{
				fixed (bool* ppOpen = &pOpen)
				{
					byte ret = BeginTabItemNative((byte*)plabel, (bool*)ppOpen, (ImGuiTabItemFlags)(0));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ReadOnlySpan<byte> label, ref bool pOpen, ImGuiTabItemFlags flags)
		{
			fixed (byte* plabel = label)
			{
				fixed (bool* ppOpen = &pOpen)
				{
					byte ret = BeginTabItemNative((byte*)plabel, (bool*)ppOpen, flags);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(ReadOnlySpan<byte> label, ref bool pOpen)
		{
			fixed (byte* plabel = label)
			{
				fixed (bool* ppOpen = &pOpen)
				{
					byte ret = BeginTabItemNative((byte*)plabel, (bool*)ppOpen, (ImGuiTabItemFlags)(0));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(string label, ref bool pOpen, ImGuiTabItemFlags flags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (bool* ppOpen = &pOpen)
			{
				byte ret = BeginTabItemNative(pStr0, (bool*)ppOpen, flags);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginTabItem(string label, ref bool pOpen)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (bool* ppOpen = &pOpen)
			{
				byte ret = BeginTabItemNative(pStr0, (bool*)ppOpen, (ImGuiTabItemFlags)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EndTabItemNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[289])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[289])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void EndTabItem()
		{
			EndTabItemNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte TabItemButtonNative(byte* label, ImGuiTabItemFlags flags)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, ImGuiTabItemFlags, byte>)funcTable[290])(label, flags);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, ImGuiTabItemFlags, byte>)funcTable[290])((nint)label, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TabItemButton(byte* label, ImGuiTabItemFlags flags)
		{
			byte ret = TabItemButtonNative(label, flags);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TabItemButton(byte* label)
		{
			byte ret = TabItemButtonNative(label, (ImGuiTabItemFlags)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TabItemButton(ref byte label, ImGuiTabItemFlags flags)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = TabItemButtonNative((byte*)plabel, flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TabItemButton(ref byte label)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = TabItemButtonNative((byte*)plabel, (ImGuiTabItemFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TabItemButton(ReadOnlySpan<byte> label, ImGuiTabItemFlags flags)
		{
			fixed (byte* plabel = label)
			{
				byte ret = TabItemButtonNative((byte*)plabel, flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TabItemButton(ReadOnlySpan<byte> label)
		{
			fixed (byte* plabel = label)
			{
				byte ret = TabItemButtonNative((byte*)plabel, (ImGuiTabItemFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TabItemButton(string label, ImGuiTabItemFlags flags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = TabItemButtonNative(pStr0, flags);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TabItemButton(string label)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = TabItemButtonNative(pStr0, (ImGuiTabItemFlags)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetTabItemClosedNative(byte* tabOrDockedWindowLabel)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte*, void>)funcTable[291])(tabOrDockedWindowLabel);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[291])((nint)tabOrDockedWindowLabel);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetTabItemClosed(byte* tabOrDockedWindowLabel)
		{
			SetTabItemClosedNative(tabOrDockedWindowLabel);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetTabItemClosed(ref byte tabOrDockedWindowLabel)
		{
			fixed (byte* ptabOrDockedWindowLabel = &tabOrDockedWindowLabel)
			{
				SetTabItemClosedNative((byte*)ptabOrDockedWindowLabel);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetTabItemClosed(ReadOnlySpan<byte> tabOrDockedWindowLabel)
		{
			fixed (byte* ptabOrDockedWindowLabel = tabOrDockedWindowLabel)
			{
				SetTabItemClosedNative((byte*)ptabOrDockedWindowLabel);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetTabItemClosed(string tabOrDockedWindowLabel)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (tabOrDockedWindowLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(tabOrDockedWindowLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(tabOrDockedWindowLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			SetTabItemClosedNative(pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint DockSpaceNative(uint id, Vector2 size, ImGuiDockNodeFlags flags, ImGuiWindowClass* windowClass)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint, Vector2, ImGuiDockNodeFlags, ImGuiWindowClass*, uint>)funcTable[292])(id, size, flags, windowClass);
			#else
			return (uint)((delegate* unmanaged[Cdecl]<uint, Vector2, ImGuiDockNodeFlags, nint, uint>)funcTable[292])(id, size, flags, (nint)windowClass);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, Vector2 size, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr windowClass)
		{
			uint ret = DockSpaceNative(id, size, flags, windowClass);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, Vector2 size, ImGuiDockNodeFlags flags)
		{
			uint ret = DockSpaceNative(id, size, flags, (ImGuiWindowClass*)(default));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, Vector2 size)
		{
			uint ret = DockSpaceNative(id, size, (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)(default));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id)
		{
			uint ret = DockSpaceNative(id, (Vector2)(new Vector2(0,0)), (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)(default));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, ImGuiDockNodeFlags flags)
		{
			uint ret = DockSpaceNative(id, (Vector2)(new Vector2(0,0)), flags, (ImGuiWindowClass*)(default));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, Vector2 size, ImGuiWindowClassPtr windowClass)
		{
			uint ret = DockSpaceNative(id, size, (ImGuiDockNodeFlags)(0), windowClass);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, ImGuiWindowClassPtr windowClass)
		{
			uint ret = DockSpaceNative(id, (Vector2)(new Vector2(0,0)), (ImGuiDockNodeFlags)(0), windowClass);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr windowClass)
		{
			uint ret = DockSpaceNative(id, (Vector2)(new Vector2(0,0)), flags, windowClass);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, Vector2 size, ImGuiDockNodeFlags flags, ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiWindowClass* pwindowClass = &windowClass)
			{
				uint ret = DockSpaceNative(id, size, flags, (ImGuiWindowClass*)pwindowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, Vector2 size, ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiWindowClass* pwindowClass = &windowClass)
			{
				uint ret = DockSpaceNative(id, size, (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)pwindowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiWindowClass* pwindowClass = &windowClass)
			{
				uint ret = DockSpaceNative(id, (Vector2)(new Vector2(0,0)), (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)pwindowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpace(uint id, ImGuiDockNodeFlags flags, ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiWindowClass* pwindowClass = &windowClass)
			{
				uint ret = DockSpaceNative(id, (Vector2)(new Vector2(0,0)), flags, (ImGuiWindowClass*)pwindowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint DockSpaceOverViewportNative(ImGuiViewport* viewport, ImGuiDockNodeFlags flags, ImGuiWindowClass* windowClass)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiViewport*, ImGuiDockNodeFlags, ImGuiWindowClass*, uint>)funcTable[293])(viewport, flags, windowClass);
			#else
			return (uint)((delegate* unmanaged[Cdecl]<nint, ImGuiDockNodeFlags, nint, uint>)funcTable[293])((nint)viewport, flags, (nint)windowClass);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr windowClass)
		{
			uint ret = DockSpaceOverViewportNative(viewport, flags, windowClass);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags)
		{
			uint ret = DockSpaceOverViewportNative(viewport, flags, (ImGuiWindowClass*)(default));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport)
		{
			uint ret = DockSpaceOverViewportNative(viewport, (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)(default));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport()
		{
			uint ret = DockSpaceOverViewportNative((ImGuiViewport*)(default), (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)(default));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiDockNodeFlags flags)
		{
			uint ret = DockSpaceOverViewportNative((ImGuiViewport*)(default), flags, (ImGuiWindowClass*)(default));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiWindowClassPtr windowClass)
		{
			uint ret = DockSpaceOverViewportNative(viewport, (ImGuiDockNodeFlags)(0), windowClass);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiWindowClassPtr windowClass)
		{
			uint ret = DockSpaceOverViewportNative((ImGuiViewport*)(default), (ImGuiDockNodeFlags)(0), windowClass);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiDockNodeFlags flags, ImGuiWindowClassPtr windowClass)
		{
			uint ret = DockSpaceOverViewportNative((ImGuiViewport*)(default), flags, windowClass);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ref ImGuiViewport viewport, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr windowClass)
		{
			fixed (ImGuiViewport* pviewport = &viewport)
			{
				uint ret = DockSpaceOverViewportNative((ImGuiViewport*)pviewport, flags, windowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ref ImGuiViewport viewport, ImGuiDockNodeFlags flags)
		{
			fixed (ImGuiViewport* pviewport = &viewport)
			{
				uint ret = DockSpaceOverViewportNative((ImGuiViewport*)pviewport, flags, (ImGuiWindowClass*)(default));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ref ImGuiViewport viewport)
		{
			fixed (ImGuiViewport* pviewport = &viewport)
			{
				uint ret = DockSpaceOverViewportNative((ImGuiViewport*)pviewport, (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)(default));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ref ImGuiViewport viewport, ImGuiWindowClassPtr windowClass)
		{
			fixed (ImGuiViewport* pviewport = &viewport)
			{
				uint ret = DockSpaceOverViewportNative((ImGuiViewport*)pviewport, (ImGuiDockNodeFlags)(0), windowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags, ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiWindowClass* pwindowClass = &windowClass)
			{
				uint ret = DockSpaceOverViewportNative(viewport, flags, (ImGuiWindowClass*)pwindowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiWindowClass* pwindowClass = &windowClass)
			{
				uint ret = DockSpaceOverViewportNative(viewport, (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)pwindowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiWindowClass* pwindowClass = &windowClass)
			{
				uint ret = DockSpaceOverViewportNative((ImGuiViewport*)(default), (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)pwindowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ImGuiDockNodeFlags flags, ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiWindowClass* pwindowClass = &windowClass)
			{
				uint ret = DockSpaceOverViewportNative((ImGuiViewport*)(default), flags, (ImGuiWindowClass*)pwindowClass);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ref ImGuiViewport viewport, ImGuiDockNodeFlags flags, ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiViewport* pviewport = &viewport)
			{
				fixed (ImGuiWindowClass* pwindowClass = &windowClass)
				{
					uint ret = DockSpaceOverViewportNative((ImGuiViewport*)pviewport, flags, (ImGuiWindowClass*)pwindowClass);
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint DockSpaceOverViewport(ref ImGuiViewport viewport, ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiViewport* pviewport = &viewport)
			{
				fixed (ImGuiWindowClass* pwindowClass = &windowClass)
				{
					uint ret = DockSpaceOverViewportNative((ImGuiViewport*)pviewport, (ImGuiDockNodeFlags)(0), (ImGuiWindowClass*)pwindowClass);
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetNextWindowDockIDNative(uint dockId, ImGuiCond cond)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<uint, ImGuiCond, void>)funcTable[294])(dockId, cond);
			#else
			((delegate* unmanaged[Cdecl]<uint, ImGuiCond, void>)funcTable[294])(dockId, cond);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextWindowDockID(uint dockId, ImGuiCond cond)
		{
			SetNextWindowDockIDNative(dockId, cond);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextWindowDockID(uint dockId)
		{
			SetNextWindowDockIDNative(dockId, (ImGuiCond)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetNextWindowClassNative(ImGuiWindowClass* windowClass)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiWindowClass*, void>)funcTable[295])(windowClass);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[295])((nint)windowClass);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextWindowClass(ImGuiWindowClassPtr windowClass)
		{
			SetNextWindowClassNative(windowClass);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextWindowClass(ref ImGuiWindowClass windowClass)
		{
			fixed (ImGuiWindowClass* pwindowClass = &windowClass)
			{
				SetNextWindowClassNative((ImGuiWindowClass*)pwindowClass);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint GetWindowDockIDNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint>)funcTable[296])();
			#else
			return (uint)((delegate* unmanaged[Cdecl]<uint>)funcTable[296])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint GetWindowDockID()
		{
			uint ret = GetWindowDockIDNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsWindowDockedNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[297])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[297])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsWindowDocked()
		{
			byte ret = IsWindowDockedNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogToTTYNative(int autoOpenDepth)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int, void>)funcTable[298])(autoOpenDepth);
			#else
			((delegate* unmanaged[Cdecl]<int, void>)funcTable[298])(autoOpenDepth);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToTTY(int autoOpenDepth)
		{
			LogToTTYNative(autoOpenDepth);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToTTY()
		{
			LogToTTYNative((int)(-1));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogToFileNative(int autoOpenDepth, byte* filename)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int, byte*, void>)funcTable[299])(autoOpenDepth, filename);
			#else
			((delegate* unmanaged[Cdecl]<int, nint, void>)funcTable[299])(autoOpenDepth, (nint)filename);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile(int autoOpenDepth, byte* filename)
		{
			LogToFileNative(autoOpenDepth, filename);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile(int autoOpenDepth)
		{
			LogToFileNative(autoOpenDepth, (byte*)(default));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile()
		{
			LogToFileNative((int)(-1), (byte*)(default));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile(byte* filename)
		{
			LogToFileNative((int)(-1), filename);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile(int autoOpenDepth, ref byte filename)
		{
			fixed (byte* pfilename = &filename)
			{
				LogToFileNative(autoOpenDepth, (byte*)pfilename);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile(ref byte filename)
		{
			fixed (byte* pfilename = &filename)
			{
				LogToFileNative((int)(-1), (byte*)pfilename);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile(int autoOpenDepth, ReadOnlySpan<byte> filename)
		{
			fixed (byte* pfilename = filename)
			{
				LogToFileNative(autoOpenDepth, (byte*)pfilename);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile(ReadOnlySpan<byte> filename)
		{
			fixed (byte* pfilename = filename)
			{
				LogToFileNative((int)(-1), (byte*)pfilename);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile(int autoOpenDepth, string filename)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			LogToFileNative(autoOpenDepth, pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToFile(string filename)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			LogToFileNative((int)(-1), pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogToClipboardNative(int autoOpenDepth)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int, void>)funcTable[300])(autoOpenDepth);
			#else
			((delegate* unmanaged[Cdecl]<int, void>)funcTable[300])(autoOpenDepth);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToClipboard(int autoOpenDepth)
		{
			LogToClipboardNative(autoOpenDepth);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogToClipboard()
		{
			LogToClipboardNative((int)(-1));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogFinishNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[301])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[301])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogFinish()
		{
			LogFinishNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogButtonsNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[302])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[302])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogButtons()
		{
			LogButtonsNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogTextVNative(byte* fmt, nuint args)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte*, nuint, void>)funcTable[303])(fmt, args);
			#else
			((delegate* unmanaged[Cdecl]<nint, nuint, void>)funcTable[303])((nint)fmt, args);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogTextV(byte* fmt, nuint args)
		{
			LogTextVNative(fmt, args);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogTextV(ref byte fmt, nuint args)
		{
			fixed (byte* pfmt = &fmt)
			{
				LogTextVNative((byte*)pfmt, args);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogTextV(ReadOnlySpan<byte> fmt, nuint args)
		{
			fixed (byte* pfmt = fmt)
			{
				LogTextVNative((byte*)pfmt, args);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void LogTextV(string fmt, nuint args)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (fmt != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(fmt);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(fmt, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			LogTextVNative(pStr0, args);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte BeginDragDropSourceNative(ImGuiDragDropFlags flags)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiDragDropFlags, byte>)funcTable[304])(flags);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<ImGuiDragDropFlags, byte>)funcTable[304])(flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginDragDropSource(ImGuiDragDropFlags flags)
		{
			byte ret = BeginDragDropSourceNative(flags);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginDragDropSource()
		{
			byte ret = BeginDragDropSourceNative((ImGuiDragDropFlags)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte SetDragDropPayloadNative(byte* type, void* data, nuint sz, ImGuiCond cond)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, void*, nuint, ImGuiCond, byte>)funcTable[305])(type, data, sz, cond);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, nint, nuint, ImGuiCond, byte>)funcTable[305])((nint)type, (nint)data, sz, cond);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool SetDragDropPayload(byte* type, void* data, nuint sz, ImGuiCond cond)
		{
			byte ret = SetDragDropPayloadNative(type, data, sz, cond);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool SetDragDropPayload(byte* type, void* data, nuint sz)
		{
			byte ret = SetDragDropPayloadNative(type, data, sz, (ImGuiCond)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool SetDragDropPayload(ref byte type, void* data, nuint sz, ImGuiCond cond)
		{
			fixed (byte* ptype = &type)
			{
				byte ret = SetDragDropPayloadNative((byte*)ptype, data, sz, cond);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool SetDragDropPayload(ref byte type, void* data, nuint sz)
		{
			fixed (byte* ptype = &type)
			{
				byte ret = SetDragDropPayloadNative((byte*)ptype, data, sz, (ImGuiCond)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool SetDragDropPayload(ReadOnlySpan<byte> type, void* data, nuint sz, ImGuiCond cond)
		{
			fixed (byte* ptype = type)
			{
				byte ret = SetDragDropPayloadNative((byte*)ptype, data, sz, cond);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool SetDragDropPayload(ReadOnlySpan<byte> type, void* data, nuint sz)
		{
			fixed (byte* ptype = type)
			{
				byte ret = SetDragDropPayloadNative((byte*)ptype, data, sz, (ImGuiCond)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool SetDragDropPayload(string type, void* data, nuint sz, ImGuiCond cond)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (type != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(type);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(type, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = SetDragDropPayloadNative(pStr0, data, sz, cond);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool SetDragDropPayload(string type, void* data, nuint sz)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (type != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(type);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(type, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = SetDragDropPayloadNative(pStr0, data, sz, (ImGuiCond)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EndDragDropSourceNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[306])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[306])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void EndDragDropSource()
		{
			EndDragDropSourceNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte BeginDragDropTargetNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[307])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[307])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginDragDropTarget()
		{
			byte ret = BeginDragDropTargetNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiPayload* AcceptDragDropPayloadNative(byte* type, ImGuiDragDropFlags flags)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, ImGuiDragDropFlags, ImGuiPayload*>)funcTable[308])(type, flags);
			#else
			return (ImGuiPayload*)((delegate* unmanaged[Cdecl]<nint, ImGuiDragDropFlags, nint>)funcTable[308])((nint)type, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPayloadPtr AcceptDragDropPayload(byte* type, ImGuiDragDropFlags flags)
		{
			ImGuiPayloadPtr ret = AcceptDragDropPayloadNative(type, flags);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPayloadPtr AcceptDragDropPayload(byte* type)
		{
			ImGuiPayloadPtr ret = AcceptDragDropPayloadNative(type, (ImGuiDragDropFlags)(0));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPayloadPtr AcceptDragDropPayload(ref byte type, ImGuiDragDropFlags flags)
		{
			fixed (byte* ptype = &type)
			{
				ImGuiPayloadPtr ret = AcceptDragDropPayloadNative((byte*)ptype, flags);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPayloadPtr AcceptDragDropPayload(ref byte type)
		{
			fixed (byte* ptype = &type)
			{
				ImGuiPayloadPtr ret = AcceptDragDropPayloadNative((byte*)ptype, (ImGuiDragDropFlags)(0));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPayloadPtr AcceptDragDropPayload(ReadOnlySpan<byte> type, ImGuiDragDropFlags flags)
		{
			fixed (byte* ptype = type)
			{
				ImGuiPayloadPtr ret = AcceptDragDropPayloadNative((byte*)ptype, flags);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPayloadPtr AcceptDragDropPayload(ReadOnlySpan<byte> type)
		{
			fixed (byte* ptype = type)
			{
				ImGuiPayloadPtr ret = AcceptDragDropPayloadNative((byte*)ptype, (ImGuiDragDropFlags)(0));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPayloadPtr AcceptDragDropPayload(string type, ImGuiDragDropFlags flags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (type != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(type);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(type, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			ImGuiPayloadPtr ret = AcceptDragDropPayloadNative(pStr0, flags);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPayloadPtr AcceptDragDropPayload(string type)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (type != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(type);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(type, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			ImGuiPayloadPtr ret = AcceptDragDropPayloadNative(pStr0, (ImGuiDragDropFlags)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EndDragDropTargetNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[309])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[309])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void EndDragDropTarget()
		{
			EndDragDropTargetNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiPayload* GetDragDropPayloadNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiPayload*>)funcTable[310])();
			#else
			return (ImGuiPayload*)((delegate* unmanaged[Cdecl]<nint>)funcTable[310])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPayloadPtr GetDragDropPayload()
		{
			ImGuiPayloadPtr ret = GetDragDropPayloadNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void BeginDisabledNative(byte disabled)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte, void>)funcTable[311])(disabled);
			#else
			((delegate* unmanaged[Cdecl]<byte, void>)funcTable[311])(disabled);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BeginDisabled(bool disabled)
		{
			BeginDisabledNative(disabled ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BeginDisabled()
		{
			BeginDisabledNative((byte)(1));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EndDisabledNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[312])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[312])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void EndDisabled()
		{
			EndDisabledNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void PushClipRectNative(Vector2 clipRectMin, Vector2 clipRectMax, byte intersectWithCurrentClipRect)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2, Vector2, byte, void>)funcTable[313])(clipRectMin, clipRectMax, intersectWithCurrentClipRect);
			#else
			((delegate* unmanaged[Cdecl]<Vector2, Vector2, byte, void>)funcTable[313])(clipRectMin, clipRectMax, intersectWithCurrentClipRect);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushClipRect(Vector2 clipRectMin, Vector2 clipRectMax, bool intersectWithCurrentClipRect)
		{
			PushClipRectNative(clipRectMin, clipRectMax, intersectWithCurrentClipRect ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void PopClipRectNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[314])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[314])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PopClipRect()
		{
			PopClipRectNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetItemDefaultFocusNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[315])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[315])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetItemDefaultFocus()
		{
			SetItemDefaultFocusNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetKeyboardFocusHereNative(int offset)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int, void>)funcTable[316])(offset);
			#else
			((delegate* unmanaged[Cdecl]<int, void>)funcTable[316])(offset);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetKeyboardFocusHere(int offset)
		{
			SetKeyboardFocusHereNative(offset);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetKeyboardFocusHere()
		{
			SetKeyboardFocusHereNative((int)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemHoveredNative(ImGuiHoveredFlags flags)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiHoveredFlags, byte>)funcTable[317])(flags);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<ImGuiHoveredFlags, byte>)funcTable[317])(flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemHovered(ImGuiHoveredFlags flags)
		{
			byte ret = IsItemHoveredNative(flags);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemHovered()
		{
			byte ret = IsItemHoveredNative((ImGuiHoveredFlags)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemActiveNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[318])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[318])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemActive()
		{
			byte ret = IsItemActiveNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemFocusedNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[319])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[319])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemFocused()
		{
			byte ret = IsItemFocusedNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemClickedNative(ImGuiMouseButton mouseButton)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiMouseButton, byte>)funcTable[320])(mouseButton);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<ImGuiMouseButton, byte>)funcTable[320])(mouseButton);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemClicked(ImGuiMouseButton mouseButton)
		{
			byte ret = IsItemClickedNative(mouseButton);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemClicked()
		{
			byte ret = IsItemClickedNative((ImGuiMouseButton)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemVisibleNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[321])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[321])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemVisible()
		{
			byte ret = IsItemVisibleNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemEditedNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[322])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[322])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemEdited()
		{
			byte ret = IsItemEditedNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemActivatedNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[323])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[323])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemActivated()
		{
			byte ret = IsItemActivatedNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemDeactivatedNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[324])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[324])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemDeactivated()
		{
			byte ret = IsItemDeactivatedNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemDeactivatedAfterEditNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[325])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[325])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemDeactivatedAfterEdit()
		{
			byte ret = IsItemDeactivatedAfterEditNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsItemToggledOpenNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[326])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[326])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsItemToggledOpen()
		{
			byte ret = IsItemToggledOpenNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsAnyItemHoveredNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[327])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[327])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsAnyItemHovered()
		{
			byte ret = IsAnyItemHoveredNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsAnyItemActiveNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[328])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[328])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsAnyItemActive()
		{
			byte ret = IsAnyItemActiveNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsAnyItemFocusedNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte>)funcTable[329])();
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte>)funcTable[329])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsAnyItemFocused()
		{
			byte ret = IsAnyItemFocusedNative();
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetItemRectMinNative(Vector2* pOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, void>)funcTable[330])(pOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[330])((nint)pOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetItemRectMin()
		{
			Vector2 ret;
			GetItemRectMinNative(&ret);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetItemRectMin(Vector2* pOut)
		{
			GetItemRectMinNative(pOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetItemRectMin(ref Vector2 pOut)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetItemRectMinNative((Vector2*)ppOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetItemRectMaxNative(Vector2* pOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, void>)funcTable[331])(pOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[331])((nint)pOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetItemRectMax()
		{
			Vector2 ret;
			GetItemRectMaxNative(&ret);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetItemRectMax(Vector2* pOut)
		{
			GetItemRectMaxNative(pOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetItemRectMax(ref Vector2 pOut)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetItemRectMaxNative((Vector2*)ppOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetItemRectSizeNative(Vector2* pOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, void>)funcTable[332])(pOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[332])((nint)pOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetItemRectSize()
		{
			Vector2 ret;
			GetItemRectSizeNative(&ret);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetItemRectSize(Vector2* pOut)
		{
			GetItemRectSizeNative(pOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetItemRectSize(ref Vector2 pOut)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetItemRectSizeNative((Vector2*)ppOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetItemAllowOverlapNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[333])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[333])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetItemAllowOverlap()
		{
			SetItemAllowOverlapNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiViewport* GetMainViewportNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiViewport*>)funcTable[334])();
			#else
			return (ImGuiViewport*)((delegate* unmanaged[Cdecl]<nint>)funcTable[334])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiViewportPtr GetMainViewport()
		{
			ImGuiViewportPtr ret = GetMainViewportNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImDrawList* GetBackgroundDrawListNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImDrawList*>)funcTable[335])();
			#else
			return (ImDrawList*)((delegate* unmanaged[Cdecl]<nint>)funcTable[335])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListPtr GetBackgroundDrawList()
		{
			ImDrawListPtr ret = GetBackgroundDrawListNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImDrawList* GetForegroundDrawListNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImDrawList*>)funcTable[336])();
			#else
			return (ImDrawList*)((delegate* unmanaged[Cdecl]<nint>)funcTable[336])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListPtr GetForegroundDrawList()
		{
			ImDrawListPtr ret = GetForegroundDrawListNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImDrawList* GetBackgroundDrawListNative(ImGuiViewport* viewport)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiViewport*, ImDrawList*>)funcTable[337])(viewport);
			#else
			return (ImDrawList*)((delegate* unmanaged[Cdecl]<nint, nint>)funcTable[337])((nint)viewport);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListPtr GetBackgroundDrawList(ImGuiViewportPtr viewport)
		{
			ImDrawListPtr ret = GetBackgroundDrawListNative(viewport);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListPtr GetBackgroundDrawList(ref ImGuiViewport viewport)
		{
			fixed (ImGuiViewport* pviewport = &viewport)
			{
				ImDrawListPtr ret = GetBackgroundDrawListNative((ImGuiViewport*)pviewport);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImDrawList* GetForegroundDrawListNative(ImGuiViewport* viewport)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiViewport*, ImDrawList*>)funcTable[338])(viewport);
			#else
			return (ImDrawList*)((delegate* unmanaged[Cdecl]<nint, nint>)funcTable[338])((nint)viewport);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListPtr GetForegroundDrawList(ImGuiViewportPtr viewport)
		{
			ImDrawListPtr ret = GetForegroundDrawListNative(viewport);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListPtr GetForegroundDrawList(ref ImGuiViewport viewport)
		{
			fixed (ImGuiViewport* pviewport = &viewport)
			{
				ImDrawListPtr ret = GetForegroundDrawListNative((ImGuiViewport*)pviewport);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsRectVisibleNative(Vector2 size)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector2, byte>)funcTable[339])(size);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<Vector2, byte>)funcTable[339])(size);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsRectVisible(Vector2 size)
		{
			byte ret = IsRectVisibleNative(size);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsRectVisibleNative(Vector2 rectMin, Vector2 rectMax)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector2, Vector2, byte>)funcTable[340])(rectMin, rectMax);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<Vector2, Vector2, byte>)funcTable[340])(rectMin, rectMax);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsRectVisible(Vector2 rectMin, Vector2 rectMax)
		{
			byte ret = IsRectVisibleNative(rectMin, rectMax);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double GetTimeNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double>)funcTable[341])();
			#else
			return (double)((delegate* unmanaged[Cdecl]<double>)funcTable[341])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double GetTime()
		{
			double ret = GetTimeNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetFrameCountNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int>)funcTable[342])();
			#else
			return (int)((delegate* unmanaged[Cdecl]<int>)funcTable[342])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetFrameCount()
		{
			int ret = GetFrameCountNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImDrawListSharedData* GetDrawListSharedDataNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImDrawListSharedData*>)funcTable[343])();
			#else
			return (ImDrawListSharedData*)((delegate* unmanaged[Cdecl]<nint>)funcTable[343])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListSharedDataPtr GetDrawListSharedData()
		{
			ImDrawListSharedDataPtr ret = GetDrawListSharedDataNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte* GetStyleColorNameNative(ImGuiCol idx)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiCol, byte*>)funcTable[344])(idx);
			#else
			return (byte*)((delegate* unmanaged[Cdecl]<ImGuiCol, nint>)funcTable[344])(idx);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte* GetStyleColorName(ImGuiCol idx)
		{
			byte* ret = GetStyleColorNameNative(idx);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static string GetStyleColorNameS(ImGuiCol idx)
		{
			string ret = Utils.DecodeStringUTF8(GetStyleColorNameNative(idx));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetStateStorageNative(ImGuiStorage* storage)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiStorage*, void>)funcTable[345])(storage);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[345])((nint)storage);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetStateStorage(ImGuiStoragePtr storage)
		{
			SetStateStorageNative(storage);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetStateStorage(ref ImGuiStorage storage)
		{
			fixed (ImGuiStorage* pstorage = &storage)
			{
				SetStateStorageNative((ImGuiStorage*)pstorage);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiStorage* GetStateStorageNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStorage*>)funcTable[346])();
			#else
			return (ImGuiStorage*)((delegate* unmanaged[Cdecl]<nint>)funcTable[346])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiStoragePtr GetStateStorage()
		{
			ImGuiStoragePtr ret = GetStateStorageNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte BeginChildFrameNative(uint id, Vector2 size, ImGuiWindowFlags flags)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint, Vector2, ImGuiWindowFlags, byte>)funcTable[347])(id, size, flags);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<uint, Vector2, ImGuiWindowFlags, byte>)funcTable[347])(id, size, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginChildFrame(uint id, Vector2 size, ImGuiWindowFlags flags)
		{
			byte ret = BeginChildFrameNative(id, size, flags);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginChildFrame(uint id, Vector2 size)
		{
			byte ret = BeginChildFrameNative(id, size, (ImGuiWindowFlags)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void EndChildFrameNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[348])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[348])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void EndChildFrame()
		{
			EndChildFrameNative();
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void CalcTextSizeNative(Vector2* pOut, byte* text, byte* textEnd, byte hideTextAfterDoubleHash, float wrapWidth)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, byte*, byte*, byte, float, void>)funcTable[349])(pOut, text, textEnd, hideTextAfterDoubleHash, wrapWidth);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, nint, byte, float, void>)funcTable[349])((nint)pOut, (nint)text, (nint)textEnd, hideTextAfterDoubleHash, wrapWidth);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(byte* text)
		{
			Vector2 ret;
			CalcTextSizeNative(&ret, text, (byte*)(default), (byte)(0), (float)(-1.0f));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(byte* text, byte* textEnd)
		{
			Vector2 ret;
			CalcTextSizeNative(&ret, text, textEnd, (byte)(0), (float)(-1.0f));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, byte* text)
		{
			CalcTextSizeNative(pOut, text, (byte*)(default), (byte)(0), (float)(-1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(byte* text, bool hideTextAfterDoubleHash)
		{
			Vector2 ret;
			CalcTextSizeNative(&ret, text, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(byte* text, byte* textEnd, bool hideTextAfterDoubleHash)
		{
			Vector2 ret;
			CalcTextSizeNative(&ret, text, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, byte* text, byte* textEnd)
		{
			CalcTextSizeNative(pOut, text, textEnd, (byte)(0), (float)(-1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(byte* text, float wrapWidth)
		{
			Vector2 ret;
			CalcTextSizeNative(&ret, text, (byte*)(default), (byte)(0), wrapWidth);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(byte* text, byte* textEnd, float wrapWidth)
		{
			Vector2 ret;
			CalcTextSizeNative(&ret, text, textEnd, (byte)(0), wrapWidth);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, byte* text, bool hideTextAfterDoubleHash)
		{
			CalcTextSizeNative(pOut, text, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, byte* text, float wrapWidth)
		{
			CalcTextSizeNative(pOut, text, (byte*)(default), (byte)(0), wrapWidth);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(byte* text, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			Vector2 ret;
			CalcTextSizeNative(&ret, text, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(byte* text, byte* textEnd, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			Vector2 ret;
			CalcTextSizeNative(&ret, text, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, byte* text, byte* textEnd, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			CalcTextSizeNative(pOut, text, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, byte* text, byte* textEnd, bool hideTextAfterDoubleHash)
		{
			CalcTextSizeNative(pOut, text, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, byte* text, byte* textEnd, float wrapWidth)
		{
			CalcTextSizeNative(pOut, text, textEnd, (byte)(0), wrapWidth);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, byte* text, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			CalcTextSizeNative(pOut, text, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(ref Vector2 pOut, byte* text, byte* textEnd, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				CalcTextSizeNative((Vector2*)ppOut, text, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(ref Vector2 pOut, byte* text, byte* textEnd, bool hideTextAfterDoubleHash)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				CalcTextSizeNative((Vector2*)ppOut, text, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(ref Vector2 pOut, byte* text, byte* textEnd)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				CalcTextSizeNative((Vector2*)ppOut, text, textEnd, (byte)(0), (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(ref Vector2 pOut, byte* text)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				CalcTextSizeNative((Vector2*)ppOut, text, (byte*)(default), (byte)(0), (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(ref Vector2 pOut, byte* text, bool hideTextAfterDoubleHash)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				CalcTextSizeNative((Vector2*)ppOut, text, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(ref Vector2 pOut, byte* text, byte* textEnd, float wrapWidth)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				CalcTextSizeNative((Vector2*)ppOut, text, textEnd, (byte)(0), wrapWidth);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(ref Vector2 pOut, byte* text, float wrapWidth)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				CalcTextSizeNative((Vector2*)ppOut, text, (byte*)(default), (byte)(0), wrapWidth);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(ref Vector2 pOut, byte* text, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				CalcTextSizeNative((Vector2*)ppOut, text, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ref byte text)
		{
			fixed (byte* ptext = &text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, (byte*)(default), (byte)(0), (float)(-1.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ref byte text, byte* textEnd)
		{
			fixed (byte* ptext = &text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, textEnd, (byte)(0), (float)(-1.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, ref byte text)
		{
			fixed (byte* ptext = &text)
			{
				CalcTextSizeNative(pOut, (byte*)ptext, (byte*)(default), (byte)(0), (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ref byte text, bool hideTextAfterDoubleHash)
		{
			fixed (byte* ptext = &text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ref byte text, byte* textEnd, bool hideTextAfterDoubleHash)
		{
			fixed (byte* ptext = &text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, ref byte text, byte* textEnd)
		{
			fixed (byte* ptext = &text)
			{
				CalcTextSizeNative(pOut, (byte*)ptext, textEnd, (byte)(0), (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ref byte text, float wrapWidth)
		{
			fixed (byte* ptext = &text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, (byte*)(default), (byte)(0), wrapWidth);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ref byte text, byte* textEnd, float wrapWidth)
		{
			fixed (byte* ptext = &text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, textEnd, (byte)(0), wrapWidth);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, ref byte text, bool hideTextAfterDoubleHash)
		{
			fixed (byte* ptext = &text)
			{
				CalcTextSizeNative(pOut, (byte*)ptext, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, ref byte text, float wrapWidth)
		{
			fixed (byte* ptext = &text)
			{
				CalcTextSizeNative(pOut, (byte*)ptext, (byte*)(default), (byte)(0), wrapWidth);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ref byte text, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			fixed (byte* ptext = &text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ref byte text, byte* textEnd, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			fixed (byte* ptext = &text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ReadOnlySpan<byte> text)
		{
			fixed (byte* ptext = text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, (byte*)(default), (byte)(0), (float)(-1.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ReadOnlySpan<byte> text, byte* textEnd)
		{
			fixed (byte* ptext = text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, textEnd, (byte)(0), (float)(-1.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, ReadOnlySpan<byte> text)
		{
			fixed (byte* ptext = text)
			{
				CalcTextSizeNative(pOut, (byte*)ptext, (byte*)(default), (byte)(0), (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ReadOnlySpan<byte> text, bool hideTextAfterDoubleHash)
		{
			fixed (byte* ptext = text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ReadOnlySpan<byte> text, byte* textEnd, bool hideTextAfterDoubleHash)
		{
			fixed (byte* ptext = text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, ReadOnlySpan<byte> text, byte* textEnd)
		{
			fixed (byte* ptext = text)
			{
				CalcTextSizeNative(pOut, (byte*)ptext, textEnd, (byte)(0), (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ReadOnlySpan<byte> text, float wrapWidth)
		{
			fixed (byte* ptext = text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, (byte*)(default), (byte)(0), wrapWidth);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ReadOnlySpan<byte> text, byte* textEnd, float wrapWidth)
		{
			fixed (byte* ptext = text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, textEnd, (byte)(0), wrapWidth);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, ReadOnlySpan<byte> text, bool hideTextAfterDoubleHash)
		{
			fixed (byte* ptext = text)
			{
				CalcTextSizeNative(pOut, (byte*)ptext, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, ReadOnlySpan<byte> text, float wrapWidth)
		{
			fixed (byte* ptext = text)
			{
				CalcTextSizeNative(pOut, (byte*)ptext, (byte*)(default), (byte)(0), wrapWidth);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ReadOnlySpan<byte> text, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			fixed (byte* ptext = text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(ReadOnlySpan<byte> text, byte* textEnd, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			fixed (byte* ptext = text)
			{
				Vector2 ret;
				CalcTextSizeNative(&ret, (byte*)ptext, textEnd, hideTextAfterDoubleHash ? (byte)1 : (byte)0, wrapWidth);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(string text)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (text != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(text);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			Vector2 ret;
			CalcTextSizeNative(&ret, pStr0, (byte*)(default), (byte)(0), (float)(-1.0f));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(string text, byte* textEnd)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (text != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(text);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			Vector2 ret;
			CalcTextSizeNative(&ret, pStr0, textEnd, (byte)(0), (float)(-1.0f));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcTextSize(Vector2* pOut, string text)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (text != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(text);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			CalcTextSizeNative(pOut, pStr0, (byte*)(default), (byte)(0), (float)(-1.0f));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 CalcTextSize(string text, bool hideTextAfterDoubleHash)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (text != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(text);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(text, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			Vector2 ret;
			CalcTextSizeNative(&ret, pStr0, (byte*)(default), hideTextAfterDoubleHash ? (byte)1 : (byte)0, (float)(-1.0f));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret;
		}
	}
}