Include generated code

Contains some manual changes and "disables"
some files that contain uncompilable code

src/ImGui.NET/Generated/ImBitVector.gen.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImBitVector
+    {
+        public ImVector Storage;
+    }
+    public unsafe partial struct ImBitVectorPtr
+    {
+        public ImBitVector* NativePtr { get; }
+        public ImBitVectorPtr(ImBitVector* nativePtr) => NativePtr = nativePtr;
+        public ImBitVectorPtr(IntPtr nativePtr) => NativePtr = (ImBitVector*)nativePtr;
+        public static implicit operator ImBitVectorPtr(ImBitVector* nativePtr) => new ImBitVectorPtr(nativePtr);
+        public static implicit operator ImBitVector* (ImBitVectorPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImBitVectorPtr(IntPtr nativePtr) => new ImBitVectorPtr(nativePtr);
+        public ImVector<uint> Storage => new ImVector<uint>(NativePtr->Storage);
+        public void Clear()
+        {
+            ImGuiNative.ImBitVector_Clear((ImBitVector*)(NativePtr));
+        }
+        public void ClearBit(int n)
+        {
+            ImGuiNative.ImBitVector_ClearBit((ImBitVector*)(NativePtr), n);
+        }
+        public void Create(int sz)
+        {
+            ImGuiNative.ImBitVector_Create((ImBitVector*)(NativePtr), sz);
+        }
+        public void SetBit(int n)
+        {
+            ImGuiNative.ImBitVector_SetBit((ImBitVector*)(NativePtr), n);
+        }
+        public bool TestBit(int n)
+        {
+            byte ret = ImGuiNative.ImBitVector_TestBit((ImBitVector*)(NativePtr), n);
+            return ret != 0;
+        }
+    }
+}

src/ImGui.NET/Generated/ImDrawDataBuilder.gen.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImDrawDataBuilder
+    {
+        public ImVector Layers_0;
+        public ImVector Layers_1;
+    }
+    public unsafe partial struct ImDrawDataBuilderPtr
+    {
+        public ImDrawDataBuilder* NativePtr { get; }
+        public ImDrawDataBuilderPtr(ImDrawDataBuilder* nativePtr) => NativePtr = nativePtr;
+        public ImDrawDataBuilderPtr(IntPtr nativePtr) => NativePtr = (ImDrawDataBuilder*)nativePtr;
+        public static implicit operator ImDrawDataBuilderPtr(ImDrawDataBuilder* nativePtr) => new ImDrawDataBuilderPtr(nativePtr);
+        public static implicit operator ImDrawDataBuilder* (ImDrawDataBuilderPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImDrawDataBuilderPtr(IntPtr nativePtr) => new ImDrawDataBuilderPtr(nativePtr);
+        public RangeAccessor<ImVector> Layers => new RangeAccessor<ImVector>(&NativePtr->Layers_0, 2);
+        public void Clear()
+        {
+            ImGuiNative.ImDrawDataBuilder_Clear((ImDrawDataBuilder*)(NativePtr));
+        }
+        public void ClearFreeMemory()
+        {
+            ImGuiNative.ImDrawDataBuilder_ClearFreeMemory((ImDrawDataBuilder*)(NativePtr));
+        }
+        public void FlattenIntoSingleLayer()
+        {
+            ImGuiNative.ImDrawDataBuilder_FlattenIntoSingleLayer((ImDrawDataBuilder*)(NativePtr));
+        }
+        public int GetDrawListCount()
+        {
+            int ret = ImGuiNative.ImDrawDataBuilder_GetDrawListCount((ImDrawDataBuilder*)(NativePtr));
+            return ret;
+        }
+    }
+}

src/ImGui.NET/Generated/ImDrawListSharedData.gen.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImDrawListSharedData
+    {
+        public Vector2 TexUvWhitePixel;
+        public ImFont* Font;
+        public float FontSize;
+        public float CurveTessellationTol;
+        public float CircleSegmentMaxError;
+        public Vector4 ClipRectFullscreen;
+        public ImDrawListFlags InitialFlags;
+        public Vector2 ArcFastVtx_0;
+        public Vector2 ArcFastVtx_1;
+        public Vector2 ArcFastVtx_2;
+        public Vector2 ArcFastVtx_3;
+        public Vector2 ArcFastVtx_4;
+        public Vector2 ArcFastVtx_5;
+        public Vector2 ArcFastVtx_6;
+        public Vector2 ArcFastVtx_7;
+        public Vector2 ArcFastVtx_8;
+        public Vector2 ArcFastVtx_9;
+        public Vector2 ArcFastVtx_10;
+        public Vector2 ArcFastVtx_11;
+        public Vector2 ArcFastVtx_12;
+        public Vector2 ArcFastVtx_13;
+        public Vector2 ArcFastVtx_14;
+        public Vector2 ArcFastVtx_15;
+        public Vector2 ArcFastVtx_16;
+        public Vector2 ArcFastVtx_17;
+        public Vector2 ArcFastVtx_18;
+        public Vector2 ArcFastVtx_19;
+        public Vector2 ArcFastVtx_20;
+        public Vector2 ArcFastVtx_21;
+        public Vector2 ArcFastVtx_22;
+        public Vector2 ArcFastVtx_23;
+        public Vector2 ArcFastVtx_24;
+        public Vector2 ArcFastVtx_25;
+        public Vector2 ArcFastVtx_26;
+        public Vector2 ArcFastVtx_27;
+        public Vector2 ArcFastVtx_28;
+        public Vector2 ArcFastVtx_29;
+        public Vector2 ArcFastVtx_30;
+        public Vector2 ArcFastVtx_31;
+        public Vector2 ArcFastVtx_32;
+        public Vector2 ArcFastVtx_33;
+        public Vector2 ArcFastVtx_34;
+        public Vector2 ArcFastVtx_35;
+        public Vector2 ArcFastVtx_36;
+        public Vector2 ArcFastVtx_37;
+        public Vector2 ArcFastVtx_38;
+        public Vector2 ArcFastVtx_39;
+        public Vector2 ArcFastVtx_40;
+        public Vector2 ArcFastVtx_41;
+        public Vector2 ArcFastVtx_42;
+        public Vector2 ArcFastVtx_43;
+        public Vector2 ArcFastVtx_44;
+        public Vector2 ArcFastVtx_45;
+        public Vector2 ArcFastVtx_46;
+        public Vector2 ArcFastVtx_47;
+        public float ArcFastRadiusCutoff;
+        public fixed byte CircleSegmentCounts[64];
+        public Vector4* TexUvLines;
+    }
+    public unsafe partial struct ImDrawListSharedDataPtr
+    {
+        public ImDrawListSharedData* NativePtr { get; }
+        public ImDrawListSharedDataPtr(ImDrawListSharedData* nativePtr) => NativePtr = nativePtr;
+        public ImDrawListSharedDataPtr(IntPtr nativePtr) => NativePtr = (ImDrawListSharedData*)nativePtr;
+        public static implicit operator ImDrawListSharedDataPtr(ImDrawListSharedData* nativePtr) => new ImDrawListSharedDataPtr(nativePtr);
+        public static implicit operator ImDrawListSharedData* (ImDrawListSharedDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImDrawListSharedDataPtr(IntPtr nativePtr) => new ImDrawListSharedDataPtr(nativePtr);
+        public ref Vector2 TexUvWhitePixel => ref Unsafe.AsRef<Vector2>(&NativePtr->TexUvWhitePixel);
+        public ImFontPtr Font => new ImFontPtr(NativePtr->Font);
+        public ref float FontSize => ref Unsafe.AsRef<float>(&NativePtr->FontSize);
+        public ref float CurveTessellationTol => ref Unsafe.AsRef<float>(&NativePtr->CurveTessellationTol);
+        public ref float CircleSegmentMaxError => ref Unsafe.AsRef<float>(&NativePtr->CircleSegmentMaxError);
+        public ref Vector4 ClipRectFullscreen => ref Unsafe.AsRef<Vector4>(&NativePtr->ClipRectFullscreen);
+        public ref ImDrawListFlags InitialFlags => ref Unsafe.AsRef<ImDrawListFlags>(&NativePtr->InitialFlags);
+        public RangeAccessor<Vector2> ArcFastVtx => new RangeAccessor<Vector2>(&NativePtr->ArcFastVtx_0, 48);
+        public ref float ArcFastRadiusCutoff => ref Unsafe.AsRef<float>(&NativePtr->ArcFastRadiusCutoff);
+        public RangeAccessor<byte> CircleSegmentCounts => new RangeAccessor<byte>(NativePtr->CircleSegmentCounts, 64);
+        public IntPtr TexUvLines { get => (IntPtr)NativePtr->TexUvLines; set => NativePtr->TexUvLines = (Vector4*)value; }
+        public void Destroy()
+        {
+            ImGuiNative.ImDrawListSharedData_destroy((IntPtr)(NativePtr));
+        }
+        public void SetCircleTessellationMaxError(float max_error)
+        {
+            ImGuiNative.ImDrawListSharedData_SetCircleTessellationMaxError((IntPtr)(NativePtr), max_error);
+        }
+    }
+}

src/ImGui.NET/Generated/ImFontBuilderIO.gen.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImFontBuilderIO
+    {
+        public IntPtr FontBuilder_Build;
+    }
+    public unsafe partial struct ImFontBuilderIOPtr
+    {
+        public ImFontBuilderIO* NativePtr { get; }
+        public ImFontBuilderIOPtr(ImFontBuilderIO* nativePtr) => NativePtr = nativePtr;
+        public ImFontBuilderIOPtr(IntPtr nativePtr) => NativePtr = (ImFontBuilderIO*)nativePtr;
+        public static implicit operator ImFontBuilderIOPtr(ImFontBuilderIO* nativePtr) => new ImFontBuilderIOPtr(nativePtr);
+        public static implicit operator ImFontBuilderIO* (ImFontBuilderIOPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImFontBuilderIOPtr(IntPtr nativePtr) => new ImFontBuilderIOPtr(nativePtr);
+        public ref IntPtr FontBuilder_Build => ref Unsafe.AsRef<IntPtr>(&NativePtr->FontBuilder_Build);
+    }
+}

src/ImGui.NET/Generated/ImGuiActivateFlags.gen.cs

@@ -0,0 +1,11 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiActivateFlags
+    {
+        None = 0,
+        PreferInput = 1,
+        PreferTweak = 2,
+        TryToPreserveState = 4,
+    }
+}

src/ImGui.NET/Generated/ImGuiAxis.gen.cs

@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    public enum ImGuiAxis
+    {
+        None = -1,
+        X = 0,
+        Y = 1,
+    }
+}

src/ImGui.NET/Generated/ImGuiButtonFlagsPrivate.gen.cs

@@ -0,0 +1,24 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiButtonFlagsPrivate
+    {
+        ImGuiButtonFlags_PressedOnClick = 16,
+        ImGuiButtonFlags_PressedOnClickRelease = 32,
+        ImGuiButtonFlags_PressedOnClickReleaseAnywhere = 64,
+        ImGuiButtonFlags_PressedOnRelease = 128,
+        ImGuiButtonFlags_PressedOnDoubleClick = 256,
+        ImGuiButtonFlags_PressedOnDragDropHold = 512,
+        ImGuiButtonFlags_Repeat = 1024,
+        ImGuiButtonFlags_FlattenChildren = 2048,
+        ImGuiButtonFlags_AllowItemOverlap = 4096,
+        ImGuiButtonFlags_DontClosePopups = 8192,
+        ImGuiButtonFlags_AlignTextBaseLine = 32768,
+        ImGuiButtonFlags_NoKeyModifiers = 65536,
+        ImGuiButtonFlags_NoHoldingActiveId = 131072,
+        ImGuiButtonFlags_NoNavFocus = 262144,
+        ImGuiButtonFlags_NoHoveredOnFocus = 524288,
+        ImGuiButtonFlags_PressedOnMask = 1008,
+        ImGuiButtonFlags_PressedOnDefault = 32,
+    }
+}

src/ImGui.NET/Generated/ImGuiColorMod.gen.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiColorMod
+    {
+        public ImGuiCol Col;
+        public Vector4 BackupValue;
+    }
+    public unsafe partial struct ImGuiColorModPtr
+    {
+        public ImGuiColorMod* NativePtr { get; }
+        public ImGuiColorModPtr(ImGuiColorMod* nativePtr) => NativePtr = nativePtr;
+        public ImGuiColorModPtr(IntPtr nativePtr) => NativePtr = (ImGuiColorMod*)nativePtr;
+        public static implicit operator ImGuiColorModPtr(ImGuiColorMod* nativePtr) => new ImGuiColorModPtr(nativePtr);
+        public static implicit operator ImGuiColorMod* (ImGuiColorModPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiColorModPtr(IntPtr nativePtr) => new ImGuiColorModPtr(nativePtr);
+        public ref ImGuiCol Col => ref Unsafe.AsRef<ImGuiCol>(&NativePtr->Col);
+        public ref Vector4 BackupValue => ref Unsafe.AsRef<Vector4>(&NativePtr->BackupValue);
+    }
+}

src/ImGui.NET/Generated/ImGuiComboFlagsPrivate.gen.cs

@@ -0,0 +1,8 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiComboFlagsPrivate
+    {
+        ImGuiComboFlags_CustomPreview = 1048576,
+    }
+}

src/ImGui.NET/Generated/ImGuiComboPreviewData.gen.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiComboPreviewData
+    {
+        public ImRect PreviewRect;
+        public Vector2 BackupCursorPos;
+        public Vector2 BackupCursorMaxPos;
+        public Vector2 BackupCursorPosPrevLine;
+        public float BackupPrevLineTextBaseOffset;
+        public ImGuiLayoutType BackupLayout;
+    }
+    public unsafe partial struct ImGuiComboPreviewDataPtr
+    {
+        public ImGuiComboPreviewData* NativePtr { get; }
+        public ImGuiComboPreviewDataPtr(ImGuiComboPreviewData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiComboPreviewDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiComboPreviewData*)nativePtr;
+        public static implicit operator ImGuiComboPreviewDataPtr(ImGuiComboPreviewData* nativePtr) => new ImGuiComboPreviewDataPtr(nativePtr);
+        public static implicit operator ImGuiComboPreviewData* (ImGuiComboPreviewDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiComboPreviewDataPtr(IntPtr nativePtr) => new ImGuiComboPreviewDataPtr(nativePtr);
+        public ref ImRect PreviewRect => ref Unsafe.AsRef<ImRect>(&NativePtr->PreviewRect);
+        public ref Vector2 BackupCursorPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorPos);
+        public ref Vector2 BackupCursorMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorMaxPos);
+        public ref Vector2 BackupCursorPosPrevLine => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorPosPrevLine);
+        public ref float BackupPrevLineTextBaseOffset => ref Unsafe.AsRef<float>(&NativePtr->BackupPrevLineTextBaseOffset);
+        public ref ImGuiLayoutType BackupLayout => ref Unsafe.AsRef<ImGuiLayoutType>(&NativePtr->BackupLayout);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiComboPreviewData_destroy((ImGuiComboPreviewData*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiContext.gen.cs.disabled

@@ -0,0 +1,488 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiContext
+    {
+        public byte Initialized;
+        public byte FontAtlasOwnedByContext;
+        public ImGuiIO IO;
+        public ImGuiPlatformIO PlatformIO;
+        public ImVector InputEventsQueue;
+        public ImVector InputEventsTrail;
+        public ImGuiStyle Style;
+        public ImGuiConfigFlags ConfigFlagsCurrFrame;
+        public ImGuiConfigFlags ConfigFlagsLastFrame;
+        public ImFont* Font;
+        public float FontSize;
+        public float FontBaseSize;
+        public IntPtr DrawListSharedData;
+        public double Time;
+        public int FrameCount;
+        public int FrameCountEnded;
+        public int FrameCountPlatformEnded;
+        public int FrameCountRendered;
+        public byte WithinFrameScope;
+        public byte WithinFrameScopeWithImplicitWindow;
+        public byte WithinEndChild;
+        public byte GcCompactAll;
+        public byte TestEngineHookItems;
+        public void* TestEngine;
+        public ImVector Windows;
+        public ImVector WindowsFocusOrder;
+        public ImVector WindowsTempSortBuffer;
+        public ImVector CurrentWindowStack;
+        public ImGuiStorage WindowsById;
+        public int WindowsActiveCount;
+        public Vector2 WindowsHoverPadding;
+        public ImGuiWindow* CurrentWindow;
+        public ImGuiWindow* HoveredWindow;
+        public ImGuiWindow* HoveredWindowUnderMovingWindow;
+        public ImGuiDockNode* HoveredDockNode;
+        public ImGuiWindow* MovingWindow;
+        public ImGuiWindow* WheelingWindow;
+        public Vector2 WheelingWindowRefMousePos;
+        public float WheelingWindowTimer;
+        public uint DebugHookIdInfo;
+        public uint HoveredId;
+        public uint HoveredIdPreviousFrame;
+        public byte HoveredIdAllowOverlap;
+        public byte HoveredIdUsingMouseWheel;
+        public byte HoveredIdPreviousFrameUsingMouseWheel;
+        public byte HoveredIdDisabled;
+        public float HoveredIdTimer;
+        public float HoveredIdNotActiveTimer;
+        public uint ActiveId;
+        public uint ActiveIdIsAlive;
+        public float ActiveIdTimer;
+        public byte ActiveIdIsJustActivated;
+        public byte ActiveIdAllowOverlap;
+        public byte ActiveIdNoClearOnFocusLoss;
+        public byte ActiveIdHasBeenPressedBefore;
+        public byte ActiveIdHasBeenEditedBefore;
+        public byte ActiveIdHasBeenEditedThisFrame;
+        public Vector2 ActiveIdClickOffset;
+        public ImGuiWindow* ActiveIdWindow;
+        public ImGuiInputSource ActiveIdSource;
+        public int ActiveIdMouseButton;
+        public uint ActiveIdPreviousFrame;
+        public byte ActiveIdPreviousFrameIsAlive;
+        public byte ActiveIdPreviousFrameHasBeenEditedBefore;
+        public ImGuiWindow* ActiveIdPreviousFrameWindow;
+        public uint LastActiveId;
+        public float LastActiveIdTimer;
+        public byte ActiveIdUsingMouseWheel;
+        public uint ActiveIdUsingNavDirMask;
+        public uint ActiveIdUsingNavInputMask;
+        public ImBitArrayForNamedKeys ActiveIdUsingKeyInputMask;
+        public ImGuiItemFlags CurrentItemFlags;
+        public ImGuiNextItemData NextItemData;
+        public ImGuiLastItemData LastItemData;
+        public ImGuiNextWindowData NextWindowData;
+        public ImVector ColorStack;
+        public ImVector StyleVarStack;
+        public ImVector FontStack;
+        public ImVector FocusScopeStack;
+        public ImVector ItemFlagsStack;
+        public ImVector GroupStack;
+        public ImVector OpenPopupStack;
+        public ImVector BeginPopupStack;
+        public int BeginMenuCount;
+        public ImVector Viewports;
+        public float CurrentDpiScale;
+        public ImGuiViewportP* CurrentViewport;
+        public ImGuiViewportP* MouseViewport;
+        public ImGuiViewportP* MouseLastHoveredViewport;
+        public uint PlatformLastFocusedViewportId;
+        public ImGuiPlatformMonitor FallbackMonitor;
+        public int ViewportFrontMostStampCount;
+        public ImGuiWindow* NavWindow;
+        public uint NavId;
+        public uint NavFocusScopeId;
+        public uint NavActivateId;
+        public uint NavActivateDownId;
+        public uint NavActivatePressedId;
+        public uint NavActivateInputId;
+        public ImGuiActivateFlags NavActivateFlags;
+        public uint NavJustMovedToId;
+        public uint NavJustMovedToFocusScopeId;
+        public ImGuiModFlags NavJustMovedToKeyMods;
+        public uint NavNextActivateId;
+        public ImGuiActivateFlags NavNextActivateFlags;
+        public ImGuiInputSource NavInputSource;
+        public ImGuiNavLayer NavLayer;
+        public byte NavIdIsAlive;
+        public byte NavMousePosDirty;
+        public byte NavDisableHighlight;
+        public byte NavDisableMouseHover;
+        public byte NavAnyRequest;
+        public byte NavInitRequest;
+        public byte NavInitRequestFromMove;
+        public uint NavInitResultId;
+        public ImRect NavInitResultRectRel;
+        public byte NavMoveSubmitted;
+        public byte NavMoveScoringItems;
+        public byte NavMoveForwardToNextFrame;
+        public ImGuiNavMoveFlags NavMoveFlags;
+        public ImGuiScrollFlags NavMoveScrollFlags;
+        public ImGuiModFlags NavMoveKeyMods;
+        public ImGuiDir NavMoveDir;
+        public ImGuiDir NavMoveDirForDebug;
+        public ImGuiDir NavMoveClipDir;
+        public ImRect NavScoringRect;
+        public ImRect NavScoringNoClipRect;
+        public int NavScoringDebugCount;
+        public int NavTabbingDir;
+        public int NavTabbingCounter;
+        public ImGuiNavItemData NavMoveResultLocal;
+        public ImGuiNavItemData NavMoveResultLocalVisible;
+        public ImGuiNavItemData NavMoveResultOther;
+        public ImGuiNavItemData NavTabbingResultFirst;
+        public ImGuiWindow* NavWindowingTarget;
+        public ImGuiWindow* NavWindowingTargetAnim;
+        public ImGuiWindow* NavWindowingListWindow;
+        public float NavWindowingTimer;
+        public float NavWindowingHighlightAlpha;
+        public byte NavWindowingToggleLayer;
+        public float DimBgRatio;
+        public ImGuiMouseCursor MouseCursor;
+        public byte DragDropActive;
+        public byte DragDropWithinSource;
+        public byte DragDropWithinTarget;
+        public ImGuiDragDropFlags DragDropSourceFlags;
+        public int DragDropSourceFrameCount;
+        public int DragDropMouseButton;
+        public ImGuiPayload DragDropPayload;
+        public ImRect DragDropTargetRect;
+        public uint DragDropTargetId;
+        public ImGuiDragDropFlags DragDropAcceptFlags;
+        public float DragDropAcceptIdCurrRectSurface;
+        public uint DragDropAcceptIdCurr;
+        public uint DragDropAcceptIdPrev;
+        public int DragDropAcceptFrameCount;
+        public uint DragDropHoldJustPressedId;
+        public ImVector DragDropPayloadBufHeap;
+        public fixed byte DragDropPayloadBufLocal[16];
+        public int ClipperTempDataStacked;
+        public ImVector ClipperTempData;
+        public ImGuiTable* CurrentTable;
+        public int TablesTempDataStacked;
+        public ImVector TablesTempData;
+        public ImPool_ImGuiTable Tables;
+        public ImVector TablesLastTimeActive;
+        public ImVector DrawChannelsTempMergeBuffer;
+        public ImGuiTabBar* CurrentTabBar;
+        public ImPool_ImGuiTabBar TabBars;
+        public ImVector CurrentTabBarStack;
+        public ImVector ShrinkWidthBuffer;
+        public Vector2 MouseLastValidPos;
+        public ImGuiInputTextState InputTextState;
+        public ImFont InputTextPasswordFont;
+        public uint TempInputId;
+        public ImGuiColorEditFlags ColorEditOptions;
+        public float ColorEditLastHue;
+        public float ColorEditLastSat;
+        public uint ColorEditLastColor;
+        public Vector4 ColorPickerRef;
+        public ImGuiComboPreviewData ComboPreviewData;
+        public float SliderGrabClickOffset;
+        public float SliderCurrentAccum;
+        public byte SliderCurrentAccumDirty;
+        public byte DragCurrentAccumDirty;
+        public float DragCurrentAccum;
+        public float DragSpeedDefaultRatio;
+        public float ScrollbarClickDeltaToGrabCenter;
+        public float DisabledAlphaBackup;
+        public short DisabledStackSize;
+        public short TooltipOverrideCount;
+        public float TooltipSlowDelay;
+        public ImVector ClipboardHandlerData;
+        public ImVector MenusIdSubmittedThisFrame;
+        public ImGuiPlatformImeData PlatformImeData;
+        public ImGuiPlatformImeData PlatformImeDataPrev;
+        public uint PlatformImeViewport;
+        public byte PlatformLocaleDecimalPoint;
+        public ImGuiDockContext DockContext;
+        public byte SettingsLoaded;
+        public float SettingsDirtyTimer;
+        public ImGuiTextBuffer SettingsIniData;
+        public ImVector SettingsHandlers;
+        public ImChunkStream SettingsWindows;
+        public ImChunkStream SettingsTables;
+        public ImVector Hooks;
+        public uint HookIdNext;
+        public byte LogEnabled;
+        public ImGuiLogType LogType;
+        public IntPtr LogFile;
+        public ImGuiTextBuffer LogBuffer;
+        public byte* LogNextPrefix;
+        public byte* LogNextSuffix;
+        public float LogLinePosY;
+        public byte LogLineFirstItem;
+        public int LogDepthRef;
+        public int LogDepthToExpand;
+        public int LogDepthToExpandDefault;
+        public ImGuiDebugLogFlags DebugLogFlags;
+        public ImGuiTextBuffer DebugLogBuf;
+        public byte DebugItemPickerActive;
+        public uint DebugItemPickerBreakId;
+        public ImGuiMetricsConfig DebugMetricsConfig;
+        public ImGuiStackTool DebugStackTool;
+        public fixed float FramerateSecPerFrame[120];
+        public int FramerateSecPerFrameIdx;
+        public int FramerateSecPerFrameCount;
+        public float FramerateSecPerFrameAccum;
+        public int WantCaptureMouseNextFrame;
+        public int WantCaptureKeyboardNextFrame;
+        public int WantTextInputNextFrame;
+        public ImVector TempBuffer;
+    }
+    public unsafe partial struct ImGuiContextPtr
+    {
+        public ImGuiContext* NativePtr { get; }
+        public ImGuiContextPtr(ImGuiContext* nativePtr) => NativePtr = nativePtr;
+        public ImGuiContextPtr(IntPtr nativePtr) => NativePtr = (ImGuiContext*)nativePtr;
+        public static implicit operator ImGuiContextPtr(ImGuiContext* nativePtr) => new ImGuiContextPtr(nativePtr);
+        public static implicit operator ImGuiContext* (ImGuiContextPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiContextPtr(IntPtr nativePtr) => new ImGuiContextPtr(nativePtr);
+        public ref bool Initialized => ref Unsafe.AsRef<bool>(&NativePtr->Initialized);
+        public ref bool FontAtlasOwnedByContext => ref Unsafe.AsRef<bool>(&NativePtr->FontAtlasOwnedByContext);
+        public ref ImGuiIO IO => ref Unsafe.AsRef<ImGuiIO>(&NativePtr->IO);
+        public ref ImGuiPlatformIO PlatformIO => ref Unsafe.AsRef<ImGuiPlatformIO>(&NativePtr->PlatformIO);
+        public ImPtrVector<ImGuiInputEventPtr> InputEventsQueue => new ImPtrVector<ImGuiInputEventPtr>(NativePtr->InputEventsQueue, Unsafe.SizeOf<ImGuiInputEvent>());
+        public ImPtrVector<ImGuiInputEventPtr> InputEventsTrail => new ImPtrVector<ImGuiInputEventPtr>(NativePtr->InputEventsTrail, Unsafe.SizeOf<ImGuiInputEvent>());
+        public ref ImGuiStyle Style => ref Unsafe.AsRef<ImGuiStyle>(&NativePtr->Style);
+        public ref ImGuiConfigFlags ConfigFlagsCurrFrame => ref Unsafe.AsRef<ImGuiConfigFlags>(&NativePtr->ConfigFlagsCurrFrame);
+        public ref ImGuiConfigFlags ConfigFlagsLastFrame => ref Unsafe.AsRef<ImGuiConfigFlags>(&NativePtr->ConfigFlagsLastFrame);
+        public ImFontPtr Font => new ImFontPtr(NativePtr->Font);
+        public ref float FontSize => ref Unsafe.AsRef<float>(&NativePtr->FontSize);
+        public ref float FontBaseSize => ref Unsafe.AsRef<float>(&NativePtr->FontBaseSize);
+        public ref IntPtr DrawListSharedData => ref Unsafe.AsRef<IntPtr>(&NativePtr->DrawListSharedData);
+        public ref double Time => ref Unsafe.AsRef<double>(&NativePtr->Time);
+        public ref int FrameCount => ref Unsafe.AsRef<int>(&NativePtr->FrameCount);
+        public ref int FrameCountEnded => ref Unsafe.AsRef<int>(&NativePtr->FrameCountEnded);
+        public ref int FrameCountPlatformEnded => ref Unsafe.AsRef<int>(&NativePtr->FrameCountPlatformEnded);
+        public ref int FrameCountRendered => ref Unsafe.AsRef<int>(&NativePtr->FrameCountRendered);
+        public ref bool WithinFrameScope => ref Unsafe.AsRef<bool>(&NativePtr->WithinFrameScope);
+        public ref bool WithinFrameScopeWithImplicitWindow => ref Unsafe.AsRef<bool>(&NativePtr->WithinFrameScopeWithImplicitWindow);
+        public ref bool WithinEndChild => ref Unsafe.AsRef<bool>(&NativePtr->WithinEndChild);
+        public ref bool GcCompactAll => ref Unsafe.AsRef<bool>(&NativePtr->GcCompactAll);
+        public ref bool TestEngineHookItems => ref Unsafe.AsRef<bool>(&NativePtr->TestEngineHookItems);
+        public IntPtr TestEngine { get => (IntPtr)NativePtr->TestEngine; set => NativePtr->TestEngine = (void*)value; }
+        public ImVector<ImGuiWindowPtr> Windows => new ImVector<ImGuiWindowPtr>(NativePtr->Windows);
+        public ImVector<ImGuiWindowPtr> WindowsFocusOrder => new ImVector<ImGuiWindowPtr>(NativePtr->WindowsFocusOrder);
+        public ImVector<ImGuiWindowPtr> WindowsTempSortBuffer => new ImVector<ImGuiWindowPtr>(NativePtr->WindowsTempSortBuffer);
+        public ImPtrVector<ImGuiWindowStackDataPtr> CurrentWindowStack => new ImPtrVector<ImGuiWindowStackDataPtr>(NativePtr->CurrentWindowStack, Unsafe.SizeOf<ImGuiWindowStackData>());
+        public ref ImGuiStorage WindowsById => ref Unsafe.AsRef<ImGuiStorage>(&NativePtr->WindowsById);
+        public ref int WindowsActiveCount => ref Unsafe.AsRef<int>(&NativePtr->WindowsActiveCount);
+        public ref Vector2 WindowsHoverPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowsHoverPadding);
+        public ImGuiWindowPtr CurrentWindow => new ImGuiWindowPtr(NativePtr->CurrentWindow);
+        public ImGuiWindowPtr HoveredWindow => new ImGuiWindowPtr(NativePtr->HoveredWindow);
+        public ImGuiWindowPtr HoveredWindowUnderMovingWindow => new ImGuiWindowPtr(NativePtr->HoveredWindowUnderMovingWindow);
+        public ImGuiDockNodePtr HoveredDockNode => new ImGuiDockNodePtr(NativePtr->HoveredDockNode);
+        public ImGuiWindowPtr MovingWindow => new ImGuiWindowPtr(NativePtr->MovingWindow);
+        public ImGuiWindowPtr WheelingWindow => new ImGuiWindowPtr(NativePtr->WheelingWindow);
+        public ref Vector2 WheelingWindowRefMousePos => ref Unsafe.AsRef<Vector2>(&NativePtr->WheelingWindowRefMousePos);
+        public ref float WheelingWindowTimer => ref Unsafe.AsRef<float>(&NativePtr->WheelingWindowTimer);
+        public ref uint DebugHookIdInfo => ref Unsafe.AsRef<uint>(&NativePtr->DebugHookIdInfo);
+        public ref uint HoveredId => ref Unsafe.AsRef<uint>(&NativePtr->HoveredId);
+        public ref uint HoveredIdPreviousFrame => ref Unsafe.AsRef<uint>(&NativePtr->HoveredIdPreviousFrame);
+        public ref bool HoveredIdAllowOverlap => ref Unsafe.AsRef<bool>(&NativePtr->HoveredIdAllowOverlap);
+        public ref bool HoveredIdUsingMouseWheel => ref Unsafe.AsRef<bool>(&NativePtr->HoveredIdUsingMouseWheel);
+        public ref bool HoveredIdPreviousFrameUsingMouseWheel => ref Unsafe.AsRef<bool>(&NativePtr->HoveredIdPreviousFrameUsingMouseWheel);
+        public ref bool HoveredIdDisabled => ref Unsafe.AsRef<bool>(&NativePtr->HoveredIdDisabled);
+        public ref float HoveredIdTimer => ref Unsafe.AsRef<float>(&NativePtr->HoveredIdTimer);
+        public ref float HoveredIdNotActiveTimer => ref Unsafe.AsRef<float>(&NativePtr->HoveredIdNotActiveTimer);
+        public ref uint ActiveId => ref Unsafe.AsRef<uint>(&NativePtr->ActiveId);
+        public ref uint ActiveIdIsAlive => ref Unsafe.AsRef<uint>(&NativePtr->ActiveIdIsAlive);
+        public ref float ActiveIdTimer => ref Unsafe.AsRef<float>(&NativePtr->ActiveIdTimer);
+        public ref bool ActiveIdIsJustActivated => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdIsJustActivated);
+        public ref bool ActiveIdAllowOverlap => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdAllowOverlap);
+        public ref bool ActiveIdNoClearOnFocusLoss => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdNoClearOnFocusLoss);
+        public ref bool ActiveIdHasBeenPressedBefore => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdHasBeenPressedBefore);
+        public ref bool ActiveIdHasBeenEditedBefore => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdHasBeenEditedBefore);
+        public ref bool ActiveIdHasBeenEditedThisFrame => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdHasBeenEditedThisFrame);
+        public ref Vector2 ActiveIdClickOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->ActiveIdClickOffset);
+        public ImGuiWindowPtr ActiveIdWindow => new ImGuiWindowPtr(NativePtr->ActiveIdWindow);
+        public ref ImGuiInputSource ActiveIdSource => ref Unsafe.AsRef<ImGuiInputSource>(&NativePtr->ActiveIdSource);
+        public ref int ActiveIdMouseButton => ref Unsafe.AsRef<int>(&NativePtr->ActiveIdMouseButton);
+        public ref uint ActiveIdPreviousFrame => ref Unsafe.AsRef<uint>(&NativePtr->ActiveIdPreviousFrame);
+        public ref bool ActiveIdPreviousFrameIsAlive => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdPreviousFrameIsAlive);
+        public ref bool ActiveIdPreviousFrameHasBeenEditedBefore => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdPreviousFrameHasBeenEditedBefore);
+        public ImGuiWindowPtr ActiveIdPreviousFrameWindow => new ImGuiWindowPtr(NativePtr->ActiveIdPreviousFrameWindow);
+        public ref uint LastActiveId => ref Unsafe.AsRef<uint>(&NativePtr->LastActiveId);
+        public ref float LastActiveIdTimer => ref Unsafe.AsRef<float>(&NativePtr->LastActiveIdTimer);
+        public ref bool ActiveIdUsingMouseWheel => ref Unsafe.AsRef<bool>(&NativePtr->ActiveIdUsingMouseWheel);
+        public ref uint ActiveIdUsingNavDirMask => ref Unsafe.AsRef<uint>(&NativePtr->ActiveIdUsingNavDirMask);
+        public ref uint ActiveIdUsingNavInputMask => ref Unsafe.AsRef<uint>(&NativePtr->ActiveIdUsingNavInputMask);
+        public ref ImBitArrayForNamedKeys ActiveIdUsingKeyInputMask => ref Unsafe.AsRef<ImBitArrayForNamedKeys>(&NativePtr->ActiveIdUsingKeyInputMask);
+        public ref ImGuiItemFlags CurrentItemFlags => ref Unsafe.AsRef<ImGuiItemFlags>(&NativePtr->CurrentItemFlags);
+        public ref ImGuiNextItemData NextItemData => ref Unsafe.AsRef<ImGuiNextItemData>(&NativePtr->NextItemData);
+        public ref ImGuiLastItemData LastItemData => ref Unsafe.AsRef<ImGuiLastItemData>(&NativePtr->LastItemData);
+        public ref ImGuiNextWindowData NextWindowData => ref Unsafe.AsRef<ImGuiNextWindowData>(&NativePtr->NextWindowData);
+        public ImPtrVector<ImGuiColorModPtr> ColorStack => new ImPtrVector<ImGuiColorModPtr>(NativePtr->ColorStack, Unsafe.SizeOf<ImGuiColorMod>());
+        public ImPtrVector<ImGuiStyleModPtr> StyleVarStack => new ImPtrVector<ImGuiStyleModPtr>(NativePtr->StyleVarStack, Unsafe.SizeOf<ImGuiStyleMod>());
+        public ImVector<ImFontPtr> FontStack => new ImVector<ImFontPtr>(NativePtr->FontStack);
+        public ImVector<uint> FocusScopeStack => new ImVector<uint>(NativePtr->FocusScopeStack);
+        public ImPtrVector<ImGuiItemFlagsPtr> ItemFlagsStack => new ImPtrVector<ImGuiItemFlagsPtr>(NativePtr->ItemFlagsStack, Unsafe.SizeOf<ImGuiItemFlags>());
+        public ImPtrVector<ImGuiGroupDataPtr> GroupStack => new ImPtrVector<ImGuiGroupDataPtr>(NativePtr->GroupStack, Unsafe.SizeOf<ImGuiGroupData>());
+        public ImPtrVector<ImGuiPopupDataPtr> OpenPopupStack => new ImPtrVector<ImGuiPopupDataPtr>(NativePtr->OpenPopupStack, Unsafe.SizeOf<ImGuiPopupData>());
+        public ImPtrVector<ImGuiPopupDataPtr> BeginPopupStack => new ImPtrVector<ImGuiPopupDataPtr>(NativePtr->BeginPopupStack, Unsafe.SizeOf<ImGuiPopupData>());
+        public ref int BeginMenuCount => ref Unsafe.AsRef<int>(&NativePtr->BeginMenuCount);
+        public ImVector<ImGuiViewportPPtr> Viewports => new ImVector<ImGuiViewportPPtr>(NativePtr->Viewports);
+        public ref float CurrentDpiScale => ref Unsafe.AsRef<float>(&NativePtr->CurrentDpiScale);
+        public ImGuiViewportPPtr CurrentViewport => new ImGuiViewportPPtr(NativePtr->CurrentViewport);
+        public ImGuiViewportPPtr MouseViewport => new ImGuiViewportPPtr(NativePtr->MouseViewport);
+        public ImGuiViewportPPtr MouseLastHoveredViewport => new ImGuiViewportPPtr(NativePtr->MouseLastHoveredViewport);
+        public ref uint PlatformLastFocusedViewportId => ref Unsafe.AsRef<uint>(&NativePtr->PlatformLastFocusedViewportId);
+        public ref ImGuiPlatformMonitor FallbackMonitor => ref Unsafe.AsRef<ImGuiPlatformMonitor>(&NativePtr->FallbackMonitor);
+        public ref int ViewportFrontMostStampCount => ref Unsafe.AsRef<int>(&NativePtr->ViewportFrontMostStampCount);
+        public ImGuiWindowPtr NavWindow => new ImGuiWindowPtr(NativePtr->NavWindow);
+        public ref uint NavId => ref Unsafe.AsRef<uint>(&NativePtr->NavId);
+        public ref uint NavFocusScopeId => ref Unsafe.AsRef<uint>(&NativePtr->NavFocusScopeId);
+        public ref uint NavActivateId => ref Unsafe.AsRef<uint>(&NativePtr->NavActivateId);
+        public ref uint NavActivateDownId => ref Unsafe.AsRef<uint>(&NativePtr->NavActivateDownId);
+        public ref uint NavActivatePressedId => ref Unsafe.AsRef<uint>(&NativePtr->NavActivatePressedId);
+        public ref uint NavActivateInputId => ref Unsafe.AsRef<uint>(&NativePtr->NavActivateInputId);
+        public ref ImGuiActivateFlags NavActivateFlags => ref Unsafe.AsRef<ImGuiActivateFlags>(&NativePtr->NavActivateFlags);
+        public ref uint NavJustMovedToId => ref Unsafe.AsRef<uint>(&NativePtr->NavJustMovedToId);
+        public ref uint NavJustMovedToFocusScopeId => ref Unsafe.AsRef<uint>(&NativePtr->NavJustMovedToFocusScopeId);
+        public ref ImGuiModFlags NavJustMovedToKeyMods => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->NavJustMovedToKeyMods);
+        public ref uint NavNextActivateId => ref Unsafe.AsRef<uint>(&NativePtr->NavNextActivateId);
+        public ref ImGuiActivateFlags NavNextActivateFlags => ref Unsafe.AsRef<ImGuiActivateFlags>(&NativePtr->NavNextActivateFlags);
+        public ref ImGuiInputSource NavInputSource => ref Unsafe.AsRef<ImGuiInputSource>(&NativePtr->NavInputSource);
+        public ref ImGuiNavLayer NavLayer => ref Unsafe.AsRef<ImGuiNavLayer>(&NativePtr->NavLayer);
+        public ref bool NavIdIsAlive => ref Unsafe.AsRef<bool>(&NativePtr->NavIdIsAlive);
+        public ref bool NavMousePosDirty => ref Unsafe.AsRef<bool>(&NativePtr->NavMousePosDirty);
+        public ref bool NavDisableHighlight => ref Unsafe.AsRef<bool>(&NativePtr->NavDisableHighlight);
+        public ref bool NavDisableMouseHover => ref Unsafe.AsRef<bool>(&NativePtr->NavDisableMouseHover);
+        public ref bool NavAnyRequest => ref Unsafe.AsRef<bool>(&NativePtr->NavAnyRequest);
+        public ref bool NavInitRequest => ref Unsafe.AsRef<bool>(&NativePtr->NavInitRequest);
+        public ref bool NavInitRequestFromMove => ref Unsafe.AsRef<bool>(&NativePtr->NavInitRequestFromMove);
+        public ref uint NavInitResultId => ref Unsafe.AsRef<uint>(&NativePtr->NavInitResultId);
+        public ref ImRect NavInitResultRectRel => ref Unsafe.AsRef<ImRect>(&NativePtr->NavInitResultRectRel);
+        public ref bool NavMoveSubmitted => ref Unsafe.AsRef<bool>(&NativePtr->NavMoveSubmitted);
+        public ref bool NavMoveScoringItems => ref Unsafe.AsRef<bool>(&NativePtr->NavMoveScoringItems);
+        public ref bool NavMoveForwardToNextFrame => ref Unsafe.AsRef<bool>(&NativePtr->NavMoveForwardToNextFrame);
+        public ref ImGuiNavMoveFlags NavMoveFlags => ref Unsafe.AsRef<ImGuiNavMoveFlags>(&NativePtr->NavMoveFlags);
+        public ref ImGuiScrollFlags NavMoveScrollFlags => ref Unsafe.AsRef<ImGuiScrollFlags>(&NativePtr->NavMoveScrollFlags);
+        public ref ImGuiModFlags NavMoveKeyMods => ref Unsafe.AsRef<ImGuiModFlags>(&NativePtr->NavMoveKeyMods);
+        public ref ImGuiDir NavMoveDir => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->NavMoveDir);
+        public ref ImGuiDir NavMoveDirForDebug => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->NavMoveDirForDebug);
+        public ref ImGuiDir NavMoveClipDir => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->NavMoveClipDir);
+        public ref ImRect NavScoringRect => ref Unsafe.AsRef<ImRect>(&NativePtr->NavScoringRect);
+        public ref ImRect NavScoringNoClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->NavScoringNoClipRect);
+        public ref int NavScoringDebugCount => ref Unsafe.AsRef<int>(&NativePtr->NavScoringDebugCount);
+        public ref int NavTabbingDir => ref Unsafe.AsRef<int>(&NativePtr->NavTabbingDir);
+        public ref int NavTabbingCounter => ref Unsafe.AsRef<int>(&NativePtr->NavTabbingCounter);
+        public ref ImGuiNavItemData NavMoveResultLocal => ref Unsafe.AsRef<ImGuiNavItemData>(&NativePtr->NavMoveResultLocal);
+        public ref ImGuiNavItemData NavMoveResultLocalVisible => ref Unsafe.AsRef<ImGuiNavItemData>(&NativePtr->NavMoveResultLocalVisible);
+        public ref ImGuiNavItemData NavMoveResultOther => ref Unsafe.AsRef<ImGuiNavItemData>(&NativePtr->NavMoveResultOther);
+        public ref ImGuiNavItemData NavTabbingResultFirst => ref Unsafe.AsRef<ImGuiNavItemData>(&NativePtr->NavTabbingResultFirst);
+        public ImGuiWindowPtr NavWindowingTarget => new ImGuiWindowPtr(NativePtr->NavWindowingTarget);
+        public ImGuiWindowPtr NavWindowingTargetAnim => new ImGuiWindowPtr(NativePtr->NavWindowingTargetAnim);
+        public ImGuiWindowPtr NavWindowingListWindow => new ImGuiWindowPtr(NativePtr->NavWindowingListWindow);
+        public ref float NavWindowingTimer => ref Unsafe.AsRef<float>(&NativePtr->NavWindowingTimer);
+        public ref float NavWindowingHighlightAlpha => ref Unsafe.AsRef<float>(&NativePtr->NavWindowingHighlightAlpha);
+        public ref bool NavWindowingToggleLayer => ref Unsafe.AsRef<bool>(&NativePtr->NavWindowingToggleLayer);
+        public ref float DimBgRatio => ref Unsafe.AsRef<float>(&NativePtr->DimBgRatio);
+        public ref ImGuiMouseCursor MouseCursor => ref Unsafe.AsRef<ImGuiMouseCursor>(&NativePtr->MouseCursor);
+        public ref bool DragDropActive => ref Unsafe.AsRef<bool>(&NativePtr->DragDropActive);
+        public ref bool DragDropWithinSource => ref Unsafe.AsRef<bool>(&NativePtr->DragDropWithinSource);
+        public ref bool DragDropWithinTarget => ref Unsafe.AsRef<bool>(&NativePtr->DragDropWithinTarget);
+        public ref ImGuiDragDropFlags DragDropSourceFlags => ref Unsafe.AsRef<ImGuiDragDropFlags>(&NativePtr->DragDropSourceFlags);
+        public ref int DragDropSourceFrameCount => ref Unsafe.AsRef<int>(&NativePtr->DragDropSourceFrameCount);
+        public ref int DragDropMouseButton => ref Unsafe.AsRef<int>(&NativePtr->DragDropMouseButton);
+        public ref ImGuiPayload DragDropPayload => ref Unsafe.AsRef<ImGuiPayload>(&NativePtr->DragDropPayload);
+        public ref ImRect DragDropTargetRect => ref Unsafe.AsRef<ImRect>(&NativePtr->DragDropTargetRect);
+        public ref uint DragDropTargetId => ref Unsafe.AsRef<uint>(&NativePtr->DragDropTargetId);
+        public ref ImGuiDragDropFlags DragDropAcceptFlags => ref Unsafe.AsRef<ImGuiDragDropFlags>(&NativePtr->DragDropAcceptFlags);
+        public ref float DragDropAcceptIdCurrRectSurface => ref Unsafe.AsRef<float>(&NativePtr->DragDropAcceptIdCurrRectSurface);
+        public ref uint DragDropAcceptIdCurr => ref Unsafe.AsRef<uint>(&NativePtr->DragDropAcceptIdCurr);
+        public ref uint DragDropAcceptIdPrev => ref Unsafe.AsRef<uint>(&NativePtr->DragDropAcceptIdPrev);
+        public ref int DragDropAcceptFrameCount => ref Unsafe.AsRef<int>(&NativePtr->DragDropAcceptFrameCount);
+        public ref uint DragDropHoldJustPressedId => ref Unsafe.AsRef<uint>(&NativePtr->DragDropHoldJustPressedId);
+        public ImVector<byte> DragDropPayloadBufHeap => new ImVector<byte>(NativePtr->DragDropPayloadBufHeap);
+        public RangeAccessor<byte> DragDropPayloadBufLocal => new RangeAccessor<byte>(NativePtr->DragDropPayloadBufLocal, 16);
+        public ref int ClipperTempDataStacked => ref Unsafe.AsRef<int>(&NativePtr->ClipperTempDataStacked);
+        public ImPtrVector<ImGuiListClipperDataPtr> ClipperTempData => new ImPtrVector<ImGuiListClipperDataPtr>(NativePtr->ClipperTempData, Unsafe.SizeOf<ImGuiListClipperData>());
+        public ImGuiTablePtr CurrentTable => new ImGuiTablePtr(NativePtr->CurrentTable);
+        public ref int TablesTempDataStacked => ref Unsafe.AsRef<int>(&NativePtr->TablesTempDataStacked);
+        public ImPtrVector<ImGuiTableTempDataPtr> TablesTempData => new ImPtrVector<ImGuiTableTempDataPtr>(NativePtr->TablesTempData, Unsafe.SizeOf<ImGuiTableTempData>());
+        public ref ImPool_ImGuiTable Tables => ref Unsafe.AsRef<ImPool_ImGuiTable>(&NativePtr->Tables);
+        public ImVector<float> TablesLastTimeActive => new ImVector<float>(NativePtr->TablesLastTimeActive);
+        public ImPtrVector<ImDrawChannelPtr> DrawChannelsTempMergeBuffer => new ImPtrVector<ImDrawChannelPtr>(NativePtr->DrawChannelsTempMergeBuffer, Unsafe.SizeOf<ImDrawChannel>());
+        public ImGuiTabBarPtr CurrentTabBar => new ImGuiTabBarPtr(NativePtr->CurrentTabBar);
+        public ref ImPool_ImGuiTabBar TabBars => ref Unsafe.AsRef<ImPool_ImGuiTabBar>(&NativePtr->TabBars);
+        public ImPtrVector<ImGuiPtrOrIndexPtr> CurrentTabBarStack => new ImPtrVector<ImGuiPtrOrIndexPtr>(NativePtr->CurrentTabBarStack, Unsafe.SizeOf<ImGuiPtrOrIndex>());
+        public ImPtrVector<ImGuiShrinkWidthItemPtr> ShrinkWidthBuffer => new ImPtrVector<ImGuiShrinkWidthItemPtr>(NativePtr->ShrinkWidthBuffer, Unsafe.SizeOf<ImGuiShrinkWidthItem>());
+        public ref Vector2 MouseLastValidPos => ref Unsafe.AsRef<Vector2>(&NativePtr->MouseLastValidPos);
+        public ref ImGuiInputTextState InputTextState => ref Unsafe.AsRef<ImGuiInputTextState>(&NativePtr->InputTextState);
+        public ref ImFont InputTextPasswordFont => ref Unsafe.AsRef<ImFont>(&NativePtr->InputTextPasswordFont);
+        public ref uint TempInputId => ref Unsafe.AsRef<uint>(&NativePtr->TempInputId);
+        public ref ImGuiColorEditFlags ColorEditOptions => ref Unsafe.AsRef<ImGuiColorEditFlags>(&NativePtr->ColorEditOptions);
+        public ref float ColorEditLastHue => ref Unsafe.AsRef<float>(&NativePtr->ColorEditLastHue);
+        public ref float ColorEditLastSat => ref Unsafe.AsRef<float>(&NativePtr->ColorEditLastSat);
+        public ref uint ColorEditLastColor => ref Unsafe.AsRef<uint>(&NativePtr->ColorEditLastColor);
+        public ref Vector4 ColorPickerRef => ref Unsafe.AsRef<Vector4>(&NativePtr->ColorPickerRef);
+        public ref ImGuiComboPreviewData ComboPreviewData => ref Unsafe.AsRef<ImGuiComboPreviewData>(&NativePtr->ComboPreviewData);
+        public ref float SliderGrabClickOffset => ref Unsafe.AsRef<float>(&NativePtr->SliderGrabClickOffset);
+        public ref float SliderCurrentAccum => ref Unsafe.AsRef<float>(&NativePtr->SliderCurrentAccum);
+        public ref bool SliderCurrentAccumDirty => ref Unsafe.AsRef<bool>(&NativePtr->SliderCurrentAccumDirty);
+        public ref bool DragCurrentAccumDirty => ref Unsafe.AsRef<bool>(&NativePtr->DragCurrentAccumDirty);
+        public ref float DragCurrentAccum => ref Unsafe.AsRef<float>(&NativePtr->DragCurrentAccum);
+        public ref float DragSpeedDefaultRatio => ref Unsafe.AsRef<float>(&NativePtr->DragSpeedDefaultRatio);
+        public ref float ScrollbarClickDeltaToGrabCenter => ref Unsafe.AsRef<float>(&NativePtr->ScrollbarClickDeltaToGrabCenter);
+        public ref float DisabledAlphaBackup => ref Unsafe.AsRef<float>(&NativePtr->DisabledAlphaBackup);
+        public ref short DisabledStackSize => ref Unsafe.AsRef<short>(&NativePtr->DisabledStackSize);
+        public ref short TooltipOverrideCount => ref Unsafe.AsRef<short>(&NativePtr->TooltipOverrideCount);
+        public ref float TooltipSlowDelay => ref Unsafe.AsRef<float>(&NativePtr->TooltipSlowDelay);
+        public ImVector<byte> ClipboardHandlerData => new ImVector<byte>(NativePtr->ClipboardHandlerData);
+        public ImVector<uint> MenusIdSubmittedThisFrame => new ImVector<uint>(NativePtr->MenusIdSubmittedThisFrame);
+        public ref ImGuiPlatformImeData PlatformImeData => ref Unsafe.AsRef<ImGuiPlatformImeData>(&NativePtr->PlatformImeData);
+        public ref ImGuiPlatformImeData PlatformImeDataPrev => ref Unsafe.AsRef<ImGuiPlatformImeData>(&NativePtr->PlatformImeDataPrev);
+        public ref uint PlatformImeViewport => ref Unsafe.AsRef<uint>(&NativePtr->PlatformImeViewport);
+        public ref byte PlatformLocaleDecimalPoint => ref Unsafe.AsRef<byte>(&NativePtr->PlatformLocaleDecimalPoint);
+        public ref ImGuiDockContext DockContext => ref Unsafe.AsRef<ImGuiDockContext>(&NativePtr->DockContext);
+        public ref bool SettingsLoaded => ref Unsafe.AsRef<bool>(&NativePtr->SettingsLoaded);
+        public ref float SettingsDirtyTimer => ref Unsafe.AsRef<float>(&NativePtr->SettingsDirtyTimer);
+        public ref ImGuiTextBuffer SettingsIniData => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->SettingsIniData);
+        public ImPtrVector<ImGuiSettingsHandlerPtr> SettingsHandlers => new ImPtrVector<ImGuiSettingsHandlerPtr>(NativePtr->SettingsHandlers, Unsafe.SizeOf<ImGuiSettingsHandler>());
+        public ref ImChunkStream SettingsWindows => ref Unsafe.AsRef<ImChunkStream>(&NativePtr->SettingsWindows);
+        public ref ImChunkStream SettingsTables => ref Unsafe.AsRef<ImChunkStream>(&NativePtr->SettingsTables);
+        public ImPtrVector<ImGuiContextHookPtr> Hooks => new ImPtrVector<ImGuiContextHookPtr>(NativePtr->Hooks, Unsafe.SizeOf<ImGuiContextHook>());
+        public ref uint HookIdNext => ref Unsafe.AsRef<uint>(&NativePtr->HookIdNext);
+        public ref bool LogEnabled => ref Unsafe.AsRef<bool>(&NativePtr->LogEnabled);
+        public ref ImGuiLogType LogType => ref Unsafe.AsRef<ImGuiLogType>(&NativePtr->LogType);
+        public ref IntPtr LogFile => ref Unsafe.AsRef<IntPtr>(&NativePtr->LogFile);
+        public ref ImGuiTextBuffer LogBuffer => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->LogBuffer);
+        public IntPtr LogNextPrefix { get => (IntPtr)NativePtr->LogNextPrefix; set => NativePtr->LogNextPrefix = (byte*)value; }
+        public IntPtr LogNextSuffix { get => (IntPtr)NativePtr->LogNextSuffix; set => NativePtr->LogNextSuffix = (byte*)value; }
+        public ref float LogLinePosY => ref Unsafe.AsRef<float>(&NativePtr->LogLinePosY);
+        public ref bool LogLineFirstItem => ref Unsafe.AsRef<bool>(&NativePtr->LogLineFirstItem);
+        public ref int LogDepthRef => ref Unsafe.AsRef<int>(&NativePtr->LogDepthRef);
+        public ref int LogDepthToExpand => ref Unsafe.AsRef<int>(&NativePtr->LogDepthToExpand);
+        public ref int LogDepthToExpandDefault => ref Unsafe.AsRef<int>(&NativePtr->LogDepthToExpandDefault);
+        public ref ImGuiDebugLogFlags DebugLogFlags => ref Unsafe.AsRef<ImGuiDebugLogFlags>(&NativePtr->DebugLogFlags);
+        public ref ImGuiTextBuffer DebugLogBuf => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->DebugLogBuf);
+        public ref bool DebugItemPickerActive => ref Unsafe.AsRef<bool>(&NativePtr->DebugItemPickerActive);
+        public ref uint DebugItemPickerBreakId => ref Unsafe.AsRef<uint>(&NativePtr->DebugItemPickerBreakId);
+        public ref ImGuiMetricsConfig DebugMetricsConfig => ref Unsafe.AsRef<ImGuiMetricsConfig>(&NativePtr->DebugMetricsConfig);
+        public ref ImGuiStackTool DebugStackTool => ref Unsafe.AsRef<ImGuiStackTool>(&NativePtr->DebugStackTool);
+        public RangeAccessor<float> FramerateSecPerFrame => new RangeAccessor<float>(NativePtr->FramerateSecPerFrame, 120);
+        public ref int FramerateSecPerFrameIdx => ref Unsafe.AsRef<int>(&NativePtr->FramerateSecPerFrameIdx);
+        public ref int FramerateSecPerFrameCount => ref Unsafe.AsRef<int>(&NativePtr->FramerateSecPerFrameCount);
+        public ref float FramerateSecPerFrameAccum => ref Unsafe.AsRef<float>(&NativePtr->FramerateSecPerFrameAccum);
+        public ref int WantCaptureMouseNextFrame => ref Unsafe.AsRef<int>(&NativePtr->WantCaptureMouseNextFrame);
+        public ref int WantCaptureKeyboardNextFrame => ref Unsafe.AsRef<int>(&NativePtr->WantCaptureKeyboardNextFrame);
+        public ref int WantTextInputNextFrame => ref Unsafe.AsRef<int>(&NativePtr->WantTextInputNextFrame);
+        public ImVector<byte> TempBuffer => new ImVector<byte>(NativePtr->TempBuffer);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiContext_destroy((IntPtr)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiContextHook.gen.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiContextHook
+    {
+        public uint HookId;
+        public ImGuiContextHookType Type;
+        public uint Owner;
+        public IntPtr Callback;
+        public void* UserData;
+    }
+    public unsafe partial struct ImGuiContextHookPtr
+    {
+        public ImGuiContextHook* NativePtr { get; }
+        public ImGuiContextHookPtr(ImGuiContextHook* nativePtr) => NativePtr = nativePtr;
+        public ImGuiContextHookPtr(IntPtr nativePtr) => NativePtr = (ImGuiContextHook*)nativePtr;
+        public static implicit operator ImGuiContextHookPtr(ImGuiContextHook* nativePtr) => new ImGuiContextHookPtr(nativePtr);
+        public static implicit operator ImGuiContextHook* (ImGuiContextHookPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiContextHookPtr(IntPtr nativePtr) => new ImGuiContextHookPtr(nativePtr);
+        public ref uint HookId => ref Unsafe.AsRef<uint>(&NativePtr->HookId);
+        public ref ImGuiContextHookType Type => ref Unsafe.AsRef<ImGuiContextHookType>(&NativePtr->Type);
+        public ref uint Owner => ref Unsafe.AsRef<uint>(&NativePtr->Owner);
+        public ref IntPtr Callback => ref Unsafe.AsRef<IntPtr>(&NativePtr->Callback);
+        public IntPtr UserData { get => (IntPtr)NativePtr->UserData; set => NativePtr->UserData = (void*)value; }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiContextHook_destroy((ImGuiContextHook*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiContextHookType.gen.cs

@@ -0,0 +1,14 @@
+namespace ImGuiNET
+{
+    public enum ImGuiContextHookType
+    {
+        NewFramePre = 0,
+        NewFramePost = 1,
+        EndFramePre = 2,
+        EndFramePost = 3,
+        RenderPre = 4,
+        RenderPost = 5,
+        Shutdown = 6,
+        PendingRemoval = 7,
+    }
+}

src/ImGui.NET/Generated/ImGuiDataAuthority.gen.cs

@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    public enum ImGuiDataAuthority
+    {
+        Auto = 0,
+        DockNode = 1,
+        Window = 2,
+    }
+}

src/ImGui.NET/Generated/ImGuiDataTypeInfo.gen.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiDataTypeInfo
+    {
+        public uint Size;
+        public byte* Name;
+        public byte* PrintFmt;
+        public byte* ScanFmt;
+    }
+    public unsafe partial struct ImGuiDataTypeInfoPtr
+    {
+        public ImGuiDataTypeInfo* NativePtr { get; }
+        public ImGuiDataTypeInfoPtr(ImGuiDataTypeInfo* nativePtr) => NativePtr = nativePtr;
+        public ImGuiDataTypeInfoPtr(IntPtr nativePtr) => NativePtr = (ImGuiDataTypeInfo*)nativePtr;
+        public static implicit operator ImGuiDataTypeInfoPtr(ImGuiDataTypeInfo* nativePtr) => new ImGuiDataTypeInfoPtr(nativePtr);
+        public static implicit operator ImGuiDataTypeInfo* (ImGuiDataTypeInfoPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiDataTypeInfoPtr(IntPtr nativePtr) => new ImGuiDataTypeInfoPtr(nativePtr);
+        public ref uint Size => ref Unsafe.AsRef<uint>(&NativePtr->Size);
+        public NullTerminatedString Name => new NullTerminatedString(NativePtr->Name);
+        public IntPtr PrintFmt { get => (IntPtr)NativePtr->PrintFmt; set => NativePtr->PrintFmt = (byte*)value; }
+        public IntPtr ScanFmt { get => (IntPtr)NativePtr->ScanFmt; set => NativePtr->ScanFmt = (byte*)value; }
+    }
+}

src/ImGui.NET/Generated/ImGuiDataTypePrivate.gen.cs

@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    public enum ImGuiDataTypePrivate
+    {
+        ImGuiDataType_String = 11,
+        ImGuiDataType_Pointer = 12,
+        ImGuiDataType_ID = 13,
+    }
+}

src/ImGui.NET/Generated/ImGuiDataTypeTempStorage.gen.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiDataTypeTempStorage
+    {
+        public fixed byte Data[8];
+    }
+    public unsafe partial struct ImGuiDataTypeTempStoragePtr
+    {
+        public ImGuiDataTypeTempStorage* NativePtr { get; }
+        public ImGuiDataTypeTempStoragePtr(ImGuiDataTypeTempStorage* nativePtr) => NativePtr = nativePtr;
+        public ImGuiDataTypeTempStoragePtr(IntPtr nativePtr) => NativePtr = (ImGuiDataTypeTempStorage*)nativePtr;
+        public static implicit operator ImGuiDataTypeTempStoragePtr(ImGuiDataTypeTempStorage* nativePtr) => new ImGuiDataTypeTempStoragePtr(nativePtr);
+        public static implicit operator ImGuiDataTypeTempStorage* (ImGuiDataTypeTempStoragePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiDataTypeTempStoragePtr(IntPtr nativePtr) => new ImGuiDataTypeTempStoragePtr(nativePtr);
+        public RangeAccessor<byte> Data => new RangeAccessor<byte>(NativePtr->Data, 8);
+    }
+}

src/ImGui.NET/Generated/ImGuiDebugLogFlags.gen.cs

@@ -0,0 +1,17 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiDebugLogFlags
+    {
+        None = 0,
+        EventActiveId = 1,
+        EventFocus = 2,
+        EventPopup = 4,
+        EventNav = 8,
+        EventIO = 16,
+        EventDocking = 32,
+        EventViewport = 64,
+        EventMask = 127,
+        OutputToTTY = 1024,
+    }
+}

src/ImGui.NET/Generated/ImGuiDockContext.gen.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiDockContext
+    {
+        public ImGuiStorage Nodes;
+        public ImVector Requests;
+        public ImVector NodesSettings;
+        public byte WantFullRebuild;
+    }
+    public unsafe partial struct ImGuiDockContextPtr
+    {
+        public ImGuiDockContext* NativePtr { get; }
+        public ImGuiDockContextPtr(ImGuiDockContext* nativePtr) => NativePtr = nativePtr;
+        public ImGuiDockContextPtr(IntPtr nativePtr) => NativePtr = (ImGuiDockContext*)nativePtr;
+        public static implicit operator ImGuiDockContextPtr(ImGuiDockContext* nativePtr) => new ImGuiDockContextPtr(nativePtr);
+        public static implicit operator ImGuiDockContext* (ImGuiDockContextPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiDockContextPtr(IntPtr nativePtr) => new ImGuiDockContextPtr(nativePtr);
+        public ref ImGuiStorage Nodes => ref Unsafe.AsRef<ImGuiStorage>(&NativePtr->Nodes);
+        public ImVector<IntPtr> Requests => new ImVector<IntPtr>(NativePtr->Requests);
+        public ImVector<IntPtr> NodesSettings => new ImVector<IntPtr>(NativePtr->NodesSettings);
+        public ref bool WantFullRebuild => ref Unsafe.AsRef<bool>(&NativePtr->WantFullRebuild);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiDockContext_destroy((ImGuiDockContext*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiDockNode.gen.cs

@@ -0,0 +1,166 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiDockNode
+    {
+        public uint ID;
+        public ImGuiDockNodeFlags SharedFlags;
+        public ImGuiDockNodeFlags LocalFlags;
+        public ImGuiDockNodeFlags LocalFlagsInWindows;
+        public ImGuiDockNodeFlags MergedFlags;
+        public ImGuiDockNodeState State;
+        public ImGuiDockNode* ParentNode;
+        public ImGuiDockNode* ChildNodes_0;
+        public ImGuiDockNode* ChildNodes_1;
+        public ImVector Windows;
+        public ImGuiTabBar* TabBar;
+        public Vector2 Pos;
+        public Vector2 Size;
+        public Vector2 SizeRef;
+        public ImGuiAxis SplitAxis;
+        public ImGuiWindowClass WindowClass;
+        public uint LastBgColor;
+        public ImGuiWindow* HostWindow;
+        public ImGuiWindow* VisibleWindow;
+        public ImGuiDockNode* CentralNode;
+        public ImGuiDockNode* OnlyNodeWithWindows;
+        public int CountNodeWithWindows;
+        public int LastFrameAlive;
+        public int LastFrameActive;
+        public int LastFrameFocused;
+        public uint LastFocusedNodeId;
+        public uint SelectedTabId;
+        public uint WantCloseTabId;
+        public ImGuiDataAuthority AuthorityForPos;
+        public ImGuiDataAuthority AuthorityForSize;
+        public ImGuiDataAuthority AuthorityForViewport;
+        public byte IsVisible;
+        public byte IsFocused;
+        public byte IsBgDrawnThisFrame;
+        public byte HasCloseButton;
+        public byte HasWindowMenuButton;
+        public byte HasCentralNodeChild;
+        public byte WantCloseAll;
+        public byte WantLockSizeOnce;
+        public byte WantMouseMove;
+        public byte WantHiddenTabBarUpdate;
+        public byte WantHiddenTabBarToggle;
+    }
+    public unsafe partial struct ImGuiDockNodePtr
+    {
+        public ImGuiDockNode* NativePtr { get; }
+        public ImGuiDockNodePtr(ImGuiDockNode* nativePtr) => NativePtr = nativePtr;
+        public ImGuiDockNodePtr(IntPtr nativePtr) => NativePtr = (ImGuiDockNode*)nativePtr;
+        public static implicit operator ImGuiDockNodePtr(ImGuiDockNode* nativePtr) => new ImGuiDockNodePtr(nativePtr);
+        public static implicit operator ImGuiDockNode* (ImGuiDockNodePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiDockNodePtr(IntPtr nativePtr) => new ImGuiDockNodePtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref ImGuiDockNodeFlags SharedFlags => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->SharedFlags);
+        public ref ImGuiDockNodeFlags LocalFlags => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->LocalFlags);
+        public ref ImGuiDockNodeFlags LocalFlagsInWindows => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->LocalFlagsInWindows);
+        public ref ImGuiDockNodeFlags MergedFlags => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->MergedFlags);
+        public ref ImGuiDockNodeState State => ref Unsafe.AsRef<ImGuiDockNodeState>(&NativePtr->State);
+        public ImGuiDockNodePtr ParentNode => new ImGuiDockNodePtr(NativePtr->ParentNode);
+        public RangeAccessor<IntPtr> ChildNodes => new RangeAccessor<IntPtr>(&NativePtr->ChildNodes_0, 2);
+        public ImVector<ImGuiWindowPtr> Windows => new ImVector<ImGuiWindowPtr>(NativePtr->Windows);
+        public ImGuiTabBarPtr TabBar => new ImGuiTabBarPtr(NativePtr->TabBar);
+        public ref Vector2 Pos => ref Unsafe.AsRef<Vector2>(&NativePtr->Pos);
+        public ref Vector2 Size => ref Unsafe.AsRef<Vector2>(&NativePtr->Size);
+        public ref Vector2 SizeRef => ref Unsafe.AsRef<Vector2>(&NativePtr->SizeRef);
+        public ref ImGuiAxis SplitAxis => ref Unsafe.AsRef<ImGuiAxis>(&NativePtr->SplitAxis);
+        public ref ImGuiWindowClass WindowClass => ref Unsafe.AsRef<ImGuiWindowClass>(&NativePtr->WindowClass);
+        public ref uint LastBgColor => ref Unsafe.AsRef<uint>(&NativePtr->LastBgColor);
+        public ImGuiWindowPtr HostWindow => new ImGuiWindowPtr(NativePtr->HostWindow);
+        public ImGuiWindowPtr VisibleWindow => new ImGuiWindowPtr(NativePtr->VisibleWindow);
+        public ImGuiDockNodePtr CentralNode => new ImGuiDockNodePtr(NativePtr->CentralNode);
+        public ImGuiDockNodePtr OnlyNodeWithWindows => new ImGuiDockNodePtr(NativePtr->OnlyNodeWithWindows);
+        public ref int CountNodeWithWindows => ref Unsafe.AsRef<int>(&NativePtr->CountNodeWithWindows);
+        public ref int LastFrameAlive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameAlive);
+        public ref int LastFrameActive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameActive);
+        public ref int LastFrameFocused => ref Unsafe.AsRef<int>(&NativePtr->LastFrameFocused);
+        public ref uint LastFocusedNodeId => ref Unsafe.AsRef<uint>(&NativePtr->LastFocusedNodeId);
+        public ref uint SelectedTabId => ref Unsafe.AsRef<uint>(&NativePtr->SelectedTabId);
+        public ref uint WantCloseTabId => ref Unsafe.AsRef<uint>(&NativePtr->WantCloseTabId);
+        public ref ImGuiDataAuthority AuthorityForPos => ref Unsafe.AsRef<ImGuiDataAuthority>(&NativePtr->AuthorityForPos);
+        public ref ImGuiDataAuthority AuthorityForSize => ref Unsafe.AsRef<ImGuiDataAuthority>(&NativePtr->AuthorityForSize);
+        public ref ImGuiDataAuthority AuthorityForViewport => ref Unsafe.AsRef<ImGuiDataAuthority>(&NativePtr->AuthorityForViewport);
+        public ref bool IsVisible => ref Unsafe.AsRef<bool>(&NativePtr->IsVisible);
+        public ref bool IsFocused => ref Unsafe.AsRef<bool>(&NativePtr->IsFocused);
+        public ref bool IsBgDrawnThisFrame => ref Unsafe.AsRef<bool>(&NativePtr->IsBgDrawnThisFrame);
+        public ref bool HasCloseButton => ref Unsafe.AsRef<bool>(&NativePtr->HasCloseButton);
+        public ref bool HasWindowMenuButton => ref Unsafe.AsRef<bool>(&NativePtr->HasWindowMenuButton);
+        public ref bool HasCentralNodeChild => ref Unsafe.AsRef<bool>(&NativePtr->HasCentralNodeChild);
+        public ref bool WantCloseAll => ref Unsafe.AsRef<bool>(&NativePtr->WantCloseAll);
+        public ref bool WantLockSizeOnce => ref Unsafe.AsRef<bool>(&NativePtr->WantLockSizeOnce);
+        public ref bool WantMouseMove => ref Unsafe.AsRef<bool>(&NativePtr->WantMouseMove);
+        public ref bool WantHiddenTabBarUpdate => ref Unsafe.AsRef<bool>(&NativePtr->WantHiddenTabBarUpdate);
+        public ref bool WantHiddenTabBarToggle => ref Unsafe.AsRef<bool>(&NativePtr->WantHiddenTabBarToggle);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiDockNode_destroy((ImGuiDockNode*)(NativePtr));
+        }
+        public bool IsCentralNode()
+        {
+            byte ret = ImGuiNative.ImGuiDockNode_IsCentralNode((ImGuiDockNode*)(NativePtr));
+            return ret != 0;
+        }
+        public bool IsDockSpace()
+        {
+            byte ret = ImGuiNative.ImGuiDockNode_IsDockSpace((ImGuiDockNode*)(NativePtr));
+            return ret != 0;
+        }
+        public bool IsEmpty()
+        {
+            byte ret = ImGuiNative.ImGuiDockNode_IsEmpty((ImGuiDockNode*)(NativePtr));
+            return ret != 0;
+        }
+        public bool IsFloatingNode()
+        {
+            byte ret = ImGuiNative.ImGuiDockNode_IsFloatingNode((ImGuiDockNode*)(NativePtr));
+            return ret != 0;
+        }
+        public bool IsHiddenTabBar()
+        {
+            byte ret = ImGuiNative.ImGuiDockNode_IsHiddenTabBar((ImGuiDockNode*)(NativePtr));
+            return ret != 0;
+        }
+        public bool IsLeafNode()
+        {
+            byte ret = ImGuiNative.ImGuiDockNode_IsLeafNode((ImGuiDockNode*)(NativePtr));
+            return ret != 0;
+        }
+        public bool IsNoTabBar()
+        {
+            byte ret = ImGuiNative.ImGuiDockNode_IsNoTabBar((ImGuiDockNode*)(NativePtr));
+            return ret != 0;
+        }
+        public bool IsRootNode()
+        {
+            byte ret = ImGuiNative.ImGuiDockNode_IsRootNode((ImGuiDockNode*)(NativePtr));
+            return ret != 0;
+        }
+        public bool IsSplitNode()
+        {
+            byte ret = ImGuiNative.ImGuiDockNode_IsSplitNode((ImGuiDockNode*)(NativePtr));
+            return ret != 0;
+        }
+        public ImRect Rect()
+        {
+            ImRect __retval;
+            ImGuiNative.ImGuiDockNode_Rect(&__retval, (ImGuiDockNode*)(NativePtr));
+            return __retval;
+        }
+        public void SetLocalFlags(ImGuiDockNodeFlags flags)
+        {
+            ImGuiNative.ImGuiDockNode_SetLocalFlags((ImGuiDockNode*)(NativePtr), flags);
+        }
+        public void UpdateMergedFlags()
+        {
+            ImGuiNative.ImGuiDockNode_UpdateMergedFlags((ImGuiDockNode*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiDockNodeFlagsPrivate.gen.cs

@@ -0,0 +1,26 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiDockNodeFlagsPrivate
+    {
+        ImGuiDockNodeFlags_DockSpace = 1024,
+        ImGuiDockNodeFlags_CentralNode = 2048,
+        ImGuiDockNodeFlags_NoTabBar = 4096,
+        ImGuiDockNodeFlags_HiddenTabBar = 8192,
+        ImGuiDockNodeFlags_NoWindowMenuButton = 16384,
+        ImGuiDockNodeFlags_NoCloseButton = 32768,
+        ImGuiDockNodeFlags_NoDocking = 65536,
+        ImGuiDockNodeFlags_NoDockingSplitMe = 131072,
+        ImGuiDockNodeFlags_NoDockingSplitOther = 262144,
+        ImGuiDockNodeFlags_NoDockingOverMe = 524288,
+        ImGuiDockNodeFlags_NoDockingOverOther = 1048576,
+        ImGuiDockNodeFlags_NoDockingOverEmpty = 2097152,
+        ImGuiDockNodeFlags_NoResizeX = 4194304,
+        ImGuiDockNodeFlags_NoResizeY = 8388608,
+        ImGuiDockNodeFlags_SharedFlagsInheritMask = -1,
+        ImGuiDockNodeFlags_NoResizeFlagsMask = 12582944,
+        ImGuiDockNodeFlags_LocalFlagsMask = 12713072,
+        ImGuiDockNodeFlags_LocalFlagsTransferMask = 12712048,
+        ImGuiDockNodeFlags_SavedFlagsMask = 12712992,
+    }
+}

src/ImGui.NET/Generated/ImGuiDockNodeState.gen.cs

@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    public enum ImGuiDockNodeState
+    {
+        Unknown = 0,
+        HostWindowHiddenBecauseSingleWindow = 1,
+        HostWindowHiddenBecauseWindowsAreResizing = 2,
+        HostWindowVisible = 3,
+    }
+}

src/ImGui.NET/Generated/ImGuiGroupData.gen.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiGroupData
+    {
+        public uint WindowID;
+        public Vector2 BackupCursorPos;
+        public Vector2 BackupCursorMaxPos;
+        public ImVec1 BackupIndent;
+        public ImVec1 BackupGroupOffset;
+        public Vector2 BackupCurrLineSize;
+        public float BackupCurrLineTextBaseOffset;
+        public uint BackupActiveIdIsAlive;
+        public byte BackupActiveIdPreviousFrameIsAlive;
+        public byte BackupHoveredIdIsAlive;
+        public byte EmitItem;
+    }
+    public unsafe partial struct ImGuiGroupDataPtr
+    {
+        public ImGuiGroupData* NativePtr { get; }
+        public ImGuiGroupDataPtr(ImGuiGroupData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiGroupDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiGroupData*)nativePtr;
+        public static implicit operator ImGuiGroupDataPtr(ImGuiGroupData* nativePtr) => new ImGuiGroupDataPtr(nativePtr);
+        public static implicit operator ImGuiGroupData* (ImGuiGroupDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiGroupDataPtr(IntPtr nativePtr) => new ImGuiGroupDataPtr(nativePtr);
+        public ref uint WindowID => ref Unsafe.AsRef<uint>(&NativePtr->WindowID);
+        public ref Vector2 BackupCursorPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorPos);
+        public ref Vector2 BackupCursorMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorMaxPos);
+        public ref ImVec1 BackupIndent => ref Unsafe.AsRef<ImVec1>(&NativePtr->BackupIndent);
+        public ref ImVec1 BackupGroupOffset => ref Unsafe.AsRef<ImVec1>(&NativePtr->BackupGroupOffset);
+        public ref Vector2 BackupCurrLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCurrLineSize);
+        public ref float BackupCurrLineTextBaseOffset => ref Unsafe.AsRef<float>(&NativePtr->BackupCurrLineTextBaseOffset);
+        public ref uint BackupActiveIdIsAlive => ref Unsafe.AsRef<uint>(&NativePtr->BackupActiveIdIsAlive);
+        public ref bool BackupActiveIdPreviousFrameIsAlive => ref Unsafe.AsRef<bool>(&NativePtr->BackupActiveIdPreviousFrameIsAlive);
+        public ref bool BackupHoveredIdIsAlive => ref Unsafe.AsRef<bool>(&NativePtr->BackupHoveredIdIsAlive);
+        public ref bool EmitItem => ref Unsafe.AsRef<bool>(&NativePtr->EmitItem);
+    }
+}

src/ImGui.NET/Generated/ImGuiInputEvent.gen.cs.disabled

@@ -0,0 +1,32 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiInputEvent
+    {
+        public ImGuiInputEventType Type;
+        public ImGuiInputSource Source;
+        public union { ImGuiInputEventMousePos MousePos; ImGuiInputEventMouseWheel MouseWheel; ImGuiInputEventMouseButton MouseButton; ImGuiInputEventMouseViewport MouseViewport; ImGuiInputEventKey Key; ImGuiInputEventText Text; ImGuiInputEventAppFocused AppFocused;} ;
+        public byte AddedByTestEngine;
+    }
+    public unsafe partial struct ImGuiInputEventPtr
+    {
+        public ImGuiInputEvent* NativePtr { get; }
+        public ImGuiInputEventPtr(ImGuiInputEvent* nativePtr) => NativePtr = nativePtr;
+        public ImGuiInputEventPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEvent*)nativePtr;
+        public static implicit operator ImGuiInputEventPtr(ImGuiInputEvent* nativePtr) => new ImGuiInputEventPtr(nativePtr);
+        public static implicit operator ImGuiInputEvent* (ImGuiInputEventPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiInputEventPtr(IntPtr nativePtr) => new ImGuiInputEventPtr(nativePtr);
+        public ref ImGuiInputEventType Type => ref Unsafe.AsRef<ImGuiInputEventType>(&NativePtr->Type);
+        public ref ImGuiInputSource Source => ref Unsafe.AsRef<ImGuiInputSource>(&NativePtr->Source);
+        public ref union { ImGuiInputEventMousePos MousePos; ImGuiInputEventMouseWheel MouseWheel; ImGuiInputEventMouseButton MouseButton; ImGuiInputEventMouseViewport MouseViewport; ImGuiInputEventKey Key; ImGuiInputEventText Text; ImGuiInputEventAppFocused AppFocused;}  => ref Unsafe.AsRef<union { ImGuiInputEventMousePos MousePos; ImGuiInputEventMouseWheel MouseWheel; ImGuiInputEventMouseButton MouseButton; ImGuiInputEventMouseViewport MouseViewport; ImGuiInputEventKey Key; ImGuiInputEventText Text; ImGuiInputEventAppFocused AppFocused;}>(&NativePtr->);
+        public ref bool AddedByTestEngine => ref Unsafe.AsRef<bool>(&NativePtr->AddedByTestEngine);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiInputEvent_destroy((ImGuiInputEvent*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiInputEventAppFocused.gen.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiInputEventAppFocused
+    {
+        public byte Focused;
+    }
+    public unsafe partial struct ImGuiInputEventAppFocusedPtr
+    {
+        public ImGuiInputEventAppFocused* NativePtr { get; }
+        public ImGuiInputEventAppFocusedPtr(ImGuiInputEventAppFocused* nativePtr) => NativePtr = nativePtr;
+        public ImGuiInputEventAppFocusedPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventAppFocused*)nativePtr;
+        public static implicit operator ImGuiInputEventAppFocusedPtr(ImGuiInputEventAppFocused* nativePtr) => new ImGuiInputEventAppFocusedPtr(nativePtr);
+        public static implicit operator ImGuiInputEventAppFocused* (ImGuiInputEventAppFocusedPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiInputEventAppFocusedPtr(IntPtr nativePtr) => new ImGuiInputEventAppFocusedPtr(nativePtr);
+        public ref bool Focused => ref Unsafe.AsRef<bool>(&NativePtr->Focused);
+    }
+}

src/ImGui.NET/Generated/ImGuiInputEventKey.gen.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiInputEventKey
+    {
+        public ImGuiKey Key;
+        public byte Down;
+        public float AnalogValue;
+    }
+    public unsafe partial struct ImGuiInputEventKeyPtr
+    {
+        public ImGuiInputEventKey* NativePtr { get; }
+        public ImGuiInputEventKeyPtr(ImGuiInputEventKey* nativePtr) => NativePtr = nativePtr;
+        public ImGuiInputEventKeyPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventKey*)nativePtr;
+        public static implicit operator ImGuiInputEventKeyPtr(ImGuiInputEventKey* nativePtr) => new ImGuiInputEventKeyPtr(nativePtr);
+        public static implicit operator ImGuiInputEventKey* (ImGuiInputEventKeyPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiInputEventKeyPtr(IntPtr nativePtr) => new ImGuiInputEventKeyPtr(nativePtr);
+        public ref ImGuiKey Key => ref Unsafe.AsRef<ImGuiKey>(&NativePtr->Key);
+        public ref bool Down => ref Unsafe.AsRef<bool>(&NativePtr->Down);
+        public ref float AnalogValue => ref Unsafe.AsRef<float>(&NativePtr->AnalogValue);
+    }
+}

src/ImGui.NET/Generated/ImGuiInputEventMouseButton.gen.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiInputEventMouseButton
+    {
+        public int Button;
+        public byte Down;
+    }
+    public unsafe partial struct ImGuiInputEventMouseButtonPtr
+    {
+        public ImGuiInputEventMouseButton* NativePtr { get; }
+        public ImGuiInputEventMouseButtonPtr(ImGuiInputEventMouseButton* nativePtr) => NativePtr = nativePtr;
+        public ImGuiInputEventMouseButtonPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventMouseButton*)nativePtr;
+        public static implicit operator ImGuiInputEventMouseButtonPtr(ImGuiInputEventMouseButton* nativePtr) => new ImGuiInputEventMouseButtonPtr(nativePtr);
+        public static implicit operator ImGuiInputEventMouseButton* (ImGuiInputEventMouseButtonPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiInputEventMouseButtonPtr(IntPtr nativePtr) => new ImGuiInputEventMouseButtonPtr(nativePtr);
+        public ref int Button => ref Unsafe.AsRef<int>(&NativePtr->Button);
+        public ref bool Down => ref Unsafe.AsRef<bool>(&NativePtr->Down);
+    }
+}

src/ImGui.NET/Generated/ImGuiInputEventMousePos.gen.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiInputEventMousePos
+    {
+        public float PosX;
+        public float PosY;
+    }
+    public unsafe partial struct ImGuiInputEventMousePosPtr
+    {
+        public ImGuiInputEventMousePos* NativePtr { get; }
+        public ImGuiInputEventMousePosPtr(ImGuiInputEventMousePos* nativePtr) => NativePtr = nativePtr;
+        public ImGuiInputEventMousePosPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventMousePos*)nativePtr;
+        public static implicit operator ImGuiInputEventMousePosPtr(ImGuiInputEventMousePos* nativePtr) => new ImGuiInputEventMousePosPtr(nativePtr);
+        public static implicit operator ImGuiInputEventMousePos* (ImGuiInputEventMousePosPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiInputEventMousePosPtr(IntPtr nativePtr) => new ImGuiInputEventMousePosPtr(nativePtr);
+        public ref float PosX => ref Unsafe.AsRef<float>(&NativePtr->PosX);
+        public ref float PosY => ref Unsafe.AsRef<float>(&NativePtr->PosY);
+    }
+}

src/ImGui.NET/Generated/ImGuiInputEventMouseViewport.gen.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiInputEventMouseViewport
+    {
+        public uint HoveredViewportID;
+    }
+    public unsafe partial struct ImGuiInputEventMouseViewportPtr
+    {
+        public ImGuiInputEventMouseViewport* NativePtr { get; }
+        public ImGuiInputEventMouseViewportPtr(ImGuiInputEventMouseViewport* nativePtr) => NativePtr = nativePtr;
+        public ImGuiInputEventMouseViewportPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventMouseViewport*)nativePtr;
+        public static implicit operator ImGuiInputEventMouseViewportPtr(ImGuiInputEventMouseViewport* nativePtr) => new ImGuiInputEventMouseViewportPtr(nativePtr);
+        public static implicit operator ImGuiInputEventMouseViewport* (ImGuiInputEventMouseViewportPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiInputEventMouseViewportPtr(IntPtr nativePtr) => new ImGuiInputEventMouseViewportPtr(nativePtr);
+        public ref uint HoveredViewportID => ref Unsafe.AsRef<uint>(&NativePtr->HoveredViewportID);
+    }
+}

src/ImGui.NET/Generated/ImGuiInputEventMouseWheel.gen.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiInputEventMouseWheel
+    {
+        public float WheelX;
+        public float WheelY;
+    }
+    public unsafe partial struct ImGuiInputEventMouseWheelPtr
+    {
+        public ImGuiInputEventMouseWheel* NativePtr { get; }
+        public ImGuiInputEventMouseWheelPtr(ImGuiInputEventMouseWheel* nativePtr) => NativePtr = nativePtr;
+        public ImGuiInputEventMouseWheelPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventMouseWheel*)nativePtr;
+        public static implicit operator ImGuiInputEventMouseWheelPtr(ImGuiInputEventMouseWheel* nativePtr) => new ImGuiInputEventMouseWheelPtr(nativePtr);
+        public static implicit operator ImGuiInputEventMouseWheel* (ImGuiInputEventMouseWheelPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiInputEventMouseWheelPtr(IntPtr nativePtr) => new ImGuiInputEventMouseWheelPtr(nativePtr);
+        public ref float WheelX => ref Unsafe.AsRef<float>(&NativePtr->WheelX);
+        public ref float WheelY => ref Unsafe.AsRef<float>(&NativePtr->WheelY);
+    }
+}

src/ImGui.NET/Generated/ImGuiInputEventText.gen.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiInputEventText
+    {
+        public uint Char;
+    }
+    public unsafe partial struct ImGuiInputEventTextPtr
+    {
+        public ImGuiInputEventText* NativePtr { get; }
+        public ImGuiInputEventTextPtr(ImGuiInputEventText* nativePtr) => NativePtr = nativePtr;
+        public ImGuiInputEventTextPtr(IntPtr nativePtr) => NativePtr = (ImGuiInputEventText*)nativePtr;
+        public static implicit operator ImGuiInputEventTextPtr(ImGuiInputEventText* nativePtr) => new ImGuiInputEventTextPtr(nativePtr);
+        public static implicit operator ImGuiInputEventText* (ImGuiInputEventTextPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiInputEventTextPtr(IntPtr nativePtr) => new ImGuiInputEventTextPtr(nativePtr);
+        public ref uint Char => ref Unsafe.AsRef<uint>(&NativePtr->Char);
+    }
+}

src/ImGui.NET/Generated/ImGuiInputEventType.gen.cs

@@ -0,0 +1,15 @@
+namespace ImGuiNET
+{
+    public enum ImGuiInputEventType
+    {
+        None = 0,
+        MousePos = 1,
+        MouseWheel = 2,
+        MouseButton = 3,
+        MouseViewport = 4,
+        Key = 5,
+        Text = 6,
+        Focus = 7,
+        COUNT = 8,
+    }
+}

src/ImGui.NET/Generated/ImGuiInputSource.gen.cs

@@ -0,0 +1,13 @@
+namespace ImGuiNET
+{
+    public enum ImGuiInputSource
+    {
+        None = 0,
+        Mouse = 1,
+        Keyboard = 2,
+        Gamepad = 3,
+        Clipboard = 4,
+        Nav = 5,
+        COUNT = 6,
+    }
+}

src/ImGui.NET/Generated/ImGuiInputTextFlagsPrivate.gen.cs

@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiInputTextFlagsPrivate
+    {
+        ImGuiInputTextFlags_Multiline = 67108864,
+        ImGuiInputTextFlags_NoMarkEdited = 134217728,
+        ImGuiInputTextFlags_MergedItem = 268435456,
+    }
+}

src/ImGui.NET/Generated/ImGuiInputTextState.gen.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiInputTextState
+    {
+        public uint ID;
+        public int CurLenW;
+        public int CurLenA;
+        public ImVector TextW;
+        public ImVector TextA;
+        public ImVector InitialTextA;
+        public byte TextAIsValid;
+        public int BufCapacityA;
+        public float ScrollX;
+        public STB_TexteditState Stb;
+        public float CursorAnim;
+        public byte CursorFollow;
+        public byte SelectedAllMouseLock;
+        public byte Edited;
+        public ImGuiInputTextFlags Flags;
+    }
+    public unsafe partial struct ImGuiInputTextStatePtr
+    {
+        public ImGuiInputTextState* NativePtr { get; }
+        public ImGuiInputTextStatePtr(ImGuiInputTextState* nativePtr) => NativePtr = nativePtr;
+        public ImGuiInputTextStatePtr(IntPtr nativePtr) => NativePtr = (ImGuiInputTextState*)nativePtr;
+        public static implicit operator ImGuiInputTextStatePtr(ImGuiInputTextState* nativePtr) => new ImGuiInputTextStatePtr(nativePtr);
+        public static implicit operator ImGuiInputTextState* (ImGuiInputTextStatePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiInputTextStatePtr(IntPtr nativePtr) => new ImGuiInputTextStatePtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref int CurLenW => ref Unsafe.AsRef<int>(&NativePtr->CurLenW);
+        public ref int CurLenA => ref Unsafe.AsRef<int>(&NativePtr->CurLenA);
+        public ImVector<ushort> TextW => new ImVector<ushort>(NativePtr->TextW);
+        public ImVector<byte> TextA => new ImVector<byte>(NativePtr->TextA);
+        public ImVector<byte> InitialTextA => new ImVector<byte>(NativePtr->InitialTextA);
+        public ref bool TextAIsValid => ref Unsafe.AsRef<bool>(&NativePtr->TextAIsValid);
+        public ref int BufCapacityA => ref Unsafe.AsRef<int>(&NativePtr->BufCapacityA);
+        public ref float ScrollX => ref Unsafe.AsRef<float>(&NativePtr->ScrollX);
+        public ref STB_TexteditState Stb => ref Unsafe.AsRef<STB_TexteditState>(&NativePtr->Stb);
+        public ref float CursorAnim => ref Unsafe.AsRef<float>(&NativePtr->CursorAnim);
+        public ref bool CursorFollow => ref Unsafe.AsRef<bool>(&NativePtr->CursorFollow);
+        public ref bool SelectedAllMouseLock => ref Unsafe.AsRef<bool>(&NativePtr->SelectedAllMouseLock);
+        public ref bool Edited => ref Unsafe.AsRef<bool>(&NativePtr->Edited);
+        public ref ImGuiInputTextFlags Flags => ref Unsafe.AsRef<ImGuiInputTextFlags>(&NativePtr->Flags);
+        public void ClearFreeMemory()
+        {
+            ImGuiNative.ImGuiInputTextState_ClearFreeMemory((ImGuiInputTextState*)(NativePtr));
+        }
+        public void ClearSelection()
+        {
+            ImGuiNative.ImGuiInputTextState_ClearSelection((ImGuiInputTextState*)(NativePtr));
+        }
+        public void ClearText()
+        {
+            ImGuiNative.ImGuiInputTextState_ClearText((ImGuiInputTextState*)(NativePtr));
+        }
+        public void CursorAnimReset()
+        {
+            ImGuiNative.ImGuiInputTextState_CursorAnimReset((ImGuiInputTextState*)(NativePtr));
+        }
+        public void CursorClamp()
+        {
+            ImGuiNative.ImGuiInputTextState_CursorClamp((ImGuiInputTextState*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiInputTextState_destroy((ImGuiInputTextState*)(NativePtr));
+        }
+        public int GetCursorPos()
+        {
+            int ret = ImGuiNative.ImGuiInputTextState_GetCursorPos((ImGuiInputTextState*)(NativePtr));
+            return ret;
+        }
+        public int GetRedoAvailCount()
+        {
+            int ret = ImGuiNative.ImGuiInputTextState_GetRedoAvailCount((ImGuiInputTextState*)(NativePtr));
+            return ret;
+        }
+        public int GetSelectionEnd()
+        {
+            int ret = ImGuiNative.ImGuiInputTextState_GetSelectionEnd((ImGuiInputTextState*)(NativePtr));
+            return ret;
+        }
+        public int GetSelectionStart()
+        {
+            int ret = ImGuiNative.ImGuiInputTextState_GetSelectionStart((ImGuiInputTextState*)(NativePtr));
+            return ret;
+        }
+        public int GetUndoAvailCount()
+        {
+            int ret = ImGuiNative.ImGuiInputTextState_GetUndoAvailCount((ImGuiInputTextState*)(NativePtr));
+            return ret;
+        }
+        public bool HasSelection()
+        {
+            byte ret = ImGuiNative.ImGuiInputTextState_HasSelection((ImGuiInputTextState*)(NativePtr));
+            return ret != 0;
+        }
+        public void OnKeyPressed(int key)
+        {
+            ImGuiNative.ImGuiInputTextState_OnKeyPressed((ImGuiInputTextState*)(NativePtr), key);
+        }
+        public void SelectAll()
+        {
+            ImGuiNative.ImGuiInputTextState_SelectAll((ImGuiInputTextState*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiItemFlags.gen.cs

@@ -0,0 +1,17 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiItemFlags
+    {
+        None = 0,
+        NoTabStop = 1,
+        ButtonRepeat = 2,
+        Disabled = 4,
+        NoNav = 8,
+        NoNavDefaultFocus = 16,
+        SelectableDontClosePopup = 32,
+        MixedValue = 64,
+        ReadOnly = 128,
+        Inputable = 256,
+    }
+}

src/ImGui.NET/Generated/ImGuiItemStatusFlags.gen.cs

@@ -0,0 +1,17 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiItemStatusFlags
+    {
+        None = 0,
+        HoveredRect = 1,
+        HasDisplayRect = 2,
+        Edited = 4,
+        ToggledSelection = 8,
+        ToggledOpen = 16,
+        HasDeactivated = 32,
+        Deactivated = 64,
+        HoveredWindow = 128,
+        FocusedByTabbing = 256,
+    }
+}

src/ImGui.NET/Generated/ImGuiKeyPrivate.gen.cs

@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    public enum ImGuiKeyPrivate
+    {
+        ImGuiKey_LegacyNativeKey_BEGIN = 0,
+        ImGuiKey_LegacyNativeKey_END = 512,
+        ImGuiKey_Gamepad_BEGIN = 617,
+        ImGuiKey_Gamepad_END = 641,
+    }
+}

src/ImGui.NET/Generated/ImGuiLastItemData.gen.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiLastItemData
+    {
+        public uint ID;
+        public ImGuiItemFlags InFlags;
+        public ImGuiItemStatusFlags StatusFlags;
+        public ImRect Rect;
+        public ImRect NavRect;
+        public ImRect DisplayRect;
+    }
+    public unsafe partial struct ImGuiLastItemDataPtr
+    {
+        public ImGuiLastItemData* NativePtr { get; }
+        public ImGuiLastItemDataPtr(ImGuiLastItemData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiLastItemDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiLastItemData*)nativePtr;
+        public static implicit operator ImGuiLastItemDataPtr(ImGuiLastItemData* nativePtr) => new ImGuiLastItemDataPtr(nativePtr);
+        public static implicit operator ImGuiLastItemData* (ImGuiLastItemDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiLastItemDataPtr(IntPtr nativePtr) => new ImGuiLastItemDataPtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref ImGuiItemFlags InFlags => ref Unsafe.AsRef<ImGuiItemFlags>(&NativePtr->InFlags);
+        public ref ImGuiItemStatusFlags StatusFlags => ref Unsafe.AsRef<ImGuiItemStatusFlags>(&NativePtr->StatusFlags);
+        public ref ImRect Rect => ref Unsafe.AsRef<ImRect>(&NativePtr->Rect);
+        public ref ImRect NavRect => ref Unsafe.AsRef<ImRect>(&NativePtr->NavRect);
+        public ref ImRect DisplayRect => ref Unsafe.AsRef<ImRect>(&NativePtr->DisplayRect);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiLastItemData_destroy((ImGuiLastItemData*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiLayoutType.gen.cs

@@ -0,0 +1,8 @@
+namespace ImGuiNET
+{
+    public enum ImGuiLayoutType
+    {
+        Horizontal = 0,
+        Vertical = 1,
+    }
+}

src/ImGui.NET/Generated/ImGuiListClipperData.gen.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiListClipperData
+    {
+        public ImGuiListClipper* ListClipper;
+        public float LossynessOffset;
+        public int StepNo;
+        public int ItemsFrozen;
+        public ImVector Ranges;
+    }
+    public unsafe partial struct ImGuiListClipperDataPtr
+    {
+        public ImGuiListClipperData* NativePtr { get; }
+        public ImGuiListClipperDataPtr(ImGuiListClipperData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiListClipperDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiListClipperData*)nativePtr;
+        public static implicit operator ImGuiListClipperDataPtr(ImGuiListClipperData* nativePtr) => new ImGuiListClipperDataPtr(nativePtr);
+        public static implicit operator ImGuiListClipperData* (ImGuiListClipperDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiListClipperDataPtr(IntPtr nativePtr) => new ImGuiListClipperDataPtr(nativePtr);
+        public ImGuiListClipperPtr ListClipper => new ImGuiListClipperPtr(NativePtr->ListClipper);
+        public ref float LossynessOffset => ref Unsafe.AsRef<float>(&NativePtr->LossynessOffset);
+        public ref int StepNo => ref Unsafe.AsRef<int>(&NativePtr->StepNo);
+        public ref int ItemsFrozen => ref Unsafe.AsRef<int>(&NativePtr->ItemsFrozen);
+        public ImPtrVector<ImGuiListClipperRangePtr> Ranges => new ImPtrVector<ImGuiListClipperRangePtr>(NativePtr->Ranges, Unsafe.SizeOf<ImGuiListClipperRange>());
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiListClipperData_destroy((ImGuiListClipperData*)(NativePtr));
+        }
+        public void Reset(ImGuiListClipperPtr clipper)
+        {
+            ImGuiListClipper* native_clipper = clipper.NativePtr;
+            ImGuiNative.ImGuiListClipperData_Reset((ImGuiListClipperData*)(NativePtr), native_clipper);
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiListClipperRange.gen.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiListClipperRange
+    {
+        public int Min;
+        public int Max;
+        public byte PosToIndexConvert;
+        public sbyte PosToIndexOffsetMin;
+        public sbyte PosToIndexOffsetMax;
+    }
+    public unsafe partial struct ImGuiListClipperRangePtr
+    {
+        public ImGuiListClipperRange* NativePtr { get; }
+        public ImGuiListClipperRangePtr(ImGuiListClipperRange* nativePtr) => NativePtr = nativePtr;
+        public ImGuiListClipperRangePtr(IntPtr nativePtr) => NativePtr = (ImGuiListClipperRange*)nativePtr;
+        public static implicit operator ImGuiListClipperRangePtr(ImGuiListClipperRange* nativePtr) => new ImGuiListClipperRangePtr(nativePtr);
+        public static implicit operator ImGuiListClipperRange* (ImGuiListClipperRangePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiListClipperRangePtr(IntPtr nativePtr) => new ImGuiListClipperRangePtr(nativePtr);
+        public ref int Min => ref Unsafe.AsRef<int>(&NativePtr->Min);
+        public ref int Max => ref Unsafe.AsRef<int>(&NativePtr->Max);
+        public ref bool PosToIndexConvert => ref Unsafe.AsRef<bool>(&NativePtr->PosToIndexConvert);
+        public ref sbyte PosToIndexOffsetMin => ref Unsafe.AsRef<sbyte>(&NativePtr->PosToIndexOffsetMin);
+        public ref sbyte PosToIndexOffsetMax => ref Unsafe.AsRef<sbyte>(&NativePtr->PosToIndexOffsetMax);
+        public ImGuiListClipperRange FromIndices(int min, int max)
+        {
+            ImGuiListClipperRange ret = ImGuiNative.ImGuiListClipperRange_FromIndices(min, max);
+            return ret;
+        }
+        public ImGuiListClipperRange FromPositions(float y1, float y2, int off_min, int off_max)
+        {
+            ImGuiListClipperRange ret = ImGuiNative.ImGuiListClipperRange_FromPositions(y1, y2, off_min, off_max);
+            return ret;
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiLogType.gen.cs

@@ -0,0 +1,11 @@
+namespace ImGuiNET
+{
+    public enum ImGuiLogType
+    {
+        None = 0,
+        TTY = 1,
+        File = 2,
+        Buffer = 3,
+        Clipboard = 4,
+    }
+}

src/ImGui.NET/Generated/ImGuiMenuColumns.gen.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiMenuColumns
+    {
+        public uint TotalWidth;
+        public uint NextTotalWidth;
+        public ushort Spacing;
+        public ushort OffsetIcon;
+        public ushort OffsetLabel;
+        public ushort OffsetShortcut;
+        public ushort OffsetMark;
+        public fixed ushort Widths[4];
+    }
+    public unsafe partial struct ImGuiMenuColumnsPtr
+    {
+        public ImGuiMenuColumns* NativePtr { get; }
+        public ImGuiMenuColumnsPtr(ImGuiMenuColumns* nativePtr) => NativePtr = nativePtr;
+        public ImGuiMenuColumnsPtr(IntPtr nativePtr) => NativePtr = (ImGuiMenuColumns*)nativePtr;
+        public static implicit operator ImGuiMenuColumnsPtr(ImGuiMenuColumns* nativePtr) => new ImGuiMenuColumnsPtr(nativePtr);
+        public static implicit operator ImGuiMenuColumns* (ImGuiMenuColumnsPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiMenuColumnsPtr(IntPtr nativePtr) => new ImGuiMenuColumnsPtr(nativePtr);
+        public ref uint TotalWidth => ref Unsafe.AsRef<uint>(&NativePtr->TotalWidth);
+        public ref uint NextTotalWidth => ref Unsafe.AsRef<uint>(&NativePtr->NextTotalWidth);
+        public ref ushort Spacing => ref Unsafe.AsRef<ushort>(&NativePtr->Spacing);
+        public ref ushort OffsetIcon => ref Unsafe.AsRef<ushort>(&NativePtr->OffsetIcon);
+        public ref ushort OffsetLabel => ref Unsafe.AsRef<ushort>(&NativePtr->OffsetLabel);
+        public ref ushort OffsetShortcut => ref Unsafe.AsRef<ushort>(&NativePtr->OffsetShortcut);
+        public ref ushort OffsetMark => ref Unsafe.AsRef<ushort>(&NativePtr->OffsetMark);
+        public RangeAccessor<ushort> Widths => new RangeAccessor<ushort>(NativePtr->Widths, 4);
+        public void CalcNextTotalWidth(bool update_offsets)
+        {
+            byte native_update_offsets = update_offsets ? (byte)1 : (byte)0;
+            ImGuiNative.ImGuiMenuColumns_CalcNextTotalWidth((ImGuiMenuColumns*)(NativePtr), native_update_offsets);
+        }
+        public float DeclColumns(float w_icon, float w_label, float w_shortcut, float w_mark)
+        {
+            float ret = ImGuiNative.ImGuiMenuColumns_DeclColumns((ImGuiMenuColumns*)(NativePtr), w_icon, w_label, w_shortcut, w_mark);
+            return ret;
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiMenuColumns_destroy((ImGuiMenuColumns*)(NativePtr));
+        }
+        public void Update(float spacing, bool window_reappearing)
+        {
+            byte native_window_reappearing = window_reappearing ? (byte)1 : (byte)0;
+            ImGuiNative.ImGuiMenuColumns_Update((ImGuiMenuColumns*)(NativePtr), spacing, native_window_reappearing);
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiMetricsConfig.gen.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiMetricsConfig
+    {
+        public byte ShowDebugLog;
+        public byte ShowStackTool;
+        public byte ShowWindowsRects;
+        public byte ShowWindowsBeginOrder;
+        public byte ShowTablesRects;
+        public byte ShowDrawCmdMesh;
+        public byte ShowDrawCmdBoundingBoxes;
+        public byte ShowDockingNodes;
+        public int ShowWindowsRectsType;
+        public int ShowTablesRectsType;
+    }
+    public unsafe partial struct ImGuiMetricsConfigPtr
+    {
+        public ImGuiMetricsConfig* NativePtr { get; }
+        public ImGuiMetricsConfigPtr(ImGuiMetricsConfig* nativePtr) => NativePtr = nativePtr;
+        public ImGuiMetricsConfigPtr(IntPtr nativePtr) => NativePtr = (ImGuiMetricsConfig*)nativePtr;
+        public static implicit operator ImGuiMetricsConfigPtr(ImGuiMetricsConfig* nativePtr) => new ImGuiMetricsConfigPtr(nativePtr);
+        public static implicit operator ImGuiMetricsConfig* (ImGuiMetricsConfigPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiMetricsConfigPtr(IntPtr nativePtr) => new ImGuiMetricsConfigPtr(nativePtr);
+        public ref bool ShowDebugLog => ref Unsafe.AsRef<bool>(&NativePtr->ShowDebugLog);
+        public ref bool ShowStackTool => ref Unsafe.AsRef<bool>(&NativePtr->ShowStackTool);
+        public ref bool ShowWindowsRects => ref Unsafe.AsRef<bool>(&NativePtr->ShowWindowsRects);
+        public ref bool ShowWindowsBeginOrder => ref Unsafe.AsRef<bool>(&NativePtr->ShowWindowsBeginOrder);
+        public ref bool ShowTablesRects => ref Unsafe.AsRef<bool>(&NativePtr->ShowTablesRects);
+        public ref bool ShowDrawCmdMesh => ref Unsafe.AsRef<bool>(&NativePtr->ShowDrawCmdMesh);
+        public ref bool ShowDrawCmdBoundingBoxes => ref Unsafe.AsRef<bool>(&NativePtr->ShowDrawCmdBoundingBoxes);
+        public ref bool ShowDockingNodes => ref Unsafe.AsRef<bool>(&NativePtr->ShowDockingNodes);
+        public ref int ShowWindowsRectsType => ref Unsafe.AsRef<int>(&NativePtr->ShowWindowsRectsType);
+        public ref int ShowTablesRectsType => ref Unsafe.AsRef<int>(&NativePtr->ShowTablesRectsType);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiMetricsConfig_destroy((ImGuiMetricsConfig*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiNavDirSourceFlags.gen.cs

@@ -0,0 +1,12 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiNavDirSourceFlags
+    {
+        None = 0,
+        RawKeyboard = 1,
+        Keyboard = 2,
+        PadDPad = 4,
+        PadLStick = 8,
+    }
+}

src/ImGui.NET/Generated/ImGuiNavHighlightFlags.gen.cs

@@ -0,0 +1,12 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiNavHighlightFlags
+    {
+        None = 0,
+        TypeDefault = 1,
+        TypeThin = 2,
+        AlwaysDraw = 4,
+        NoRounding = 8,
+    }
+}

src/ImGui.NET/Generated/ImGuiNavItemData.gen.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiNavItemData
+    {
+        public ImGuiWindow* Window;
+        public uint ID;
+        public uint FocusScopeId;
+        public ImRect RectRel;
+        public ImGuiItemFlags InFlags;
+        public float DistBox;
+        public float DistCenter;
+        public float DistAxial;
+    }
+    public unsafe partial struct ImGuiNavItemDataPtr
+    {
+        public ImGuiNavItemData* NativePtr { get; }
+        public ImGuiNavItemDataPtr(ImGuiNavItemData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiNavItemDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiNavItemData*)nativePtr;
+        public static implicit operator ImGuiNavItemDataPtr(ImGuiNavItemData* nativePtr) => new ImGuiNavItemDataPtr(nativePtr);
+        public static implicit operator ImGuiNavItemData* (ImGuiNavItemDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiNavItemDataPtr(IntPtr nativePtr) => new ImGuiNavItemDataPtr(nativePtr);
+        public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref uint FocusScopeId => ref Unsafe.AsRef<uint>(&NativePtr->FocusScopeId);
+        public ref ImRect RectRel => ref Unsafe.AsRef<ImRect>(&NativePtr->RectRel);
+        public ref ImGuiItemFlags InFlags => ref Unsafe.AsRef<ImGuiItemFlags>(&NativePtr->InFlags);
+        public ref float DistBox => ref Unsafe.AsRef<float>(&NativePtr->DistBox);
+        public ref float DistCenter => ref Unsafe.AsRef<float>(&NativePtr->DistCenter);
+        public ref float DistAxial => ref Unsafe.AsRef<float>(&NativePtr->DistAxial);
+        public void Clear()
+        {
+            ImGuiNative.ImGuiNavItemData_Clear((ImGuiNavItemData*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiNavItemData_destroy((ImGuiNavItemData*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiNavLayer.gen.cs

@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    public enum ImGuiNavLayer
+    {
+        Main = 0,
+        Menu = 1,
+        COUNT = 2,
+    }
+}

src/ImGui.NET/Generated/ImGuiNavMoveFlags.gen.cs

@@ -0,0 +1,21 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiNavMoveFlags
+    {
+        None = 0,
+        LoopX = 1,
+        LoopY = 2,
+        WrapX = 4,
+        WrapY = 8,
+        AllowCurrentNavId = 16,
+        AlsoScoreVisibleSet = 32,
+        ScrollToEdgeY = 64,
+        Forwarded = 128,
+        DebugNoResult = 256,
+        FocusApi = 512,
+        Tabbing = 1024,
+        Activate = 2048,
+        DontSetNavHighlight = 4096,
+    }
+}

src/ImGui.NET/Generated/ImGuiNavReadMode.gen.cs

@@ -0,0 +1,12 @@
+namespace ImGuiNET
+{
+    public enum ImGuiNavReadMode
+    {
+        Down = 0,
+        Pressed = 1,
+        Released = 2,
+        Repeat = 3,
+        RepeatSlow = 4,
+        RepeatFast = 5,
+    }
+}

src/ImGui.NET/Generated/ImGuiNextItemData.gen.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiNextItemData
+    {
+        public ImGuiNextItemDataFlags Flags;
+        public float Width;
+        public uint FocusScopeId;
+        public ImGuiCond OpenCond;
+        public byte OpenVal;
+    }
+    public unsafe partial struct ImGuiNextItemDataPtr
+    {
+        public ImGuiNextItemData* NativePtr { get; }
+        public ImGuiNextItemDataPtr(ImGuiNextItemData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiNextItemDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiNextItemData*)nativePtr;
+        public static implicit operator ImGuiNextItemDataPtr(ImGuiNextItemData* nativePtr) => new ImGuiNextItemDataPtr(nativePtr);
+        public static implicit operator ImGuiNextItemData* (ImGuiNextItemDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiNextItemDataPtr(IntPtr nativePtr) => new ImGuiNextItemDataPtr(nativePtr);
+        public ref ImGuiNextItemDataFlags Flags => ref Unsafe.AsRef<ImGuiNextItemDataFlags>(&NativePtr->Flags);
+        public ref float Width => ref Unsafe.AsRef<float>(&NativePtr->Width);
+        public ref uint FocusScopeId => ref Unsafe.AsRef<uint>(&NativePtr->FocusScopeId);
+        public ref ImGuiCond OpenCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->OpenCond);
+        public ref bool OpenVal => ref Unsafe.AsRef<bool>(&NativePtr->OpenVal);
+        public void ClearFlags()
+        {
+            ImGuiNative.ImGuiNextItemData_ClearFlags((ImGuiNextItemData*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiNextItemData_destroy((ImGuiNextItemData*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiNextItemDataFlags.gen.cs

@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiNextItemDataFlags
+    {
+        None = 0,
+        HasWidth = 1,
+        HasOpen = 2,
+    }
+}

src/ImGui.NET/Generated/ImGuiNextWindowData.gen.cs.disabled

@@ -0,0 +1,68 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiNextWindowData
+    {
+        public ImGuiNextWindowDataFlags Flags;
+        public ImGuiCond PosCond;
+        public ImGuiCond SizeCond;
+        public ImGuiCond CollapsedCond;
+        public ImGuiCond DockCond;
+        public Vector2 PosVal;
+        public Vector2 PosPivotVal;
+        public Vector2 SizeVal;
+        public Vector2 ContentSizeVal;
+        public Vector2 ScrollVal;
+        public byte PosUndock;
+        public byte CollapsedVal;
+        public ImRect SizeConstraintRect;
+        public ImGuiSizeCallback SizeCallback;
+        public void* SizeCallbackUserData;
+        public float BgAlphaVal;
+        public uint ViewportId;
+        public uint DockId;
+        public ImGuiWindowClass WindowClass;
+        public Vector2 MenuBarOffsetMinVal;
+    }
+    public unsafe partial struct ImGuiNextWindowDataPtr
+    {
+        public ImGuiNextWindowData* NativePtr { get; }
+        public ImGuiNextWindowDataPtr(ImGuiNextWindowData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiNextWindowDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiNextWindowData*)nativePtr;
+        public static implicit operator ImGuiNextWindowDataPtr(ImGuiNextWindowData* nativePtr) => new ImGuiNextWindowDataPtr(nativePtr);
+        public static implicit operator ImGuiNextWindowData* (ImGuiNextWindowDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiNextWindowDataPtr(IntPtr nativePtr) => new ImGuiNextWindowDataPtr(nativePtr);
+        public ref ImGuiNextWindowDataFlags Flags => ref Unsafe.AsRef<ImGuiNextWindowDataFlags>(&NativePtr->Flags);
+        public ref ImGuiCond PosCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->PosCond);
+        public ref ImGuiCond SizeCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SizeCond);
+        public ref ImGuiCond CollapsedCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->CollapsedCond);
+        public ref ImGuiCond DockCond => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->DockCond);
+        public ref Vector2 PosVal => ref Unsafe.AsRef<Vector2>(&NativePtr->PosVal);
+        public ref Vector2 PosPivotVal => ref Unsafe.AsRef<Vector2>(&NativePtr->PosPivotVal);
+        public ref Vector2 SizeVal => ref Unsafe.AsRef<Vector2>(&NativePtr->SizeVal);
+        public ref Vector2 ContentSizeVal => ref Unsafe.AsRef<Vector2>(&NativePtr->ContentSizeVal);
+        public ref Vector2 ScrollVal => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollVal);
+        public ref bool PosUndock => ref Unsafe.AsRef<bool>(&NativePtr->PosUndock);
+        public ref bool CollapsedVal => ref Unsafe.AsRef<bool>(&NativePtr->CollapsedVal);
+        public ref ImRect SizeConstraintRect => ref Unsafe.AsRef<ImRect>(&NativePtr->SizeConstraintRect);
+        public ref ImGuiSizeCallback SizeCallback => ref Unsafe.AsRef<ImGuiSizeCallback>(&NativePtr->SizeCallback);
+        public IntPtr SizeCallbackUserData { get => (IntPtr)NativePtr->SizeCallbackUserData; set => NativePtr->SizeCallbackUserData = (void*)value; }
+        public ref float BgAlphaVal => ref Unsafe.AsRef<float>(&NativePtr->BgAlphaVal);
+        public ref uint ViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ViewportId);
+        public ref uint DockId => ref Unsafe.AsRef<uint>(&NativePtr->DockId);
+        public ref ImGuiWindowClass WindowClass => ref Unsafe.AsRef<ImGuiWindowClass>(&NativePtr->WindowClass);
+        public ref Vector2 MenuBarOffsetMinVal => ref Unsafe.AsRef<Vector2>(&NativePtr->MenuBarOffsetMinVal);
+        public void ClearFlags()
+        {
+            ImGuiNative.ImGuiNextWindowData_ClearFlags((ImGuiNextWindowData*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiNextWindowData_destroy((ImGuiNextWindowData*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiNextWindowDataFlags.gen.cs

@@ -0,0 +1,19 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiNextWindowDataFlags
+    {
+        None = 0,
+        HasPos = 1,
+        HasSize = 2,
+        HasContentSize = 4,
+        HasCollapsed = 8,
+        HasSizeConstraint = 16,
+        HasFocus = 32,
+        HasBgAlpha = 64,
+        HasScroll = 128,
+        HasViewport = 256,
+        HasDock = 512,
+        HasWindowClass = 1024,
+    }
+}

src/ImGui.NET/Generated/ImGuiOldColumnData.gen.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiOldColumnData
+    {
+        public float OffsetNorm;
+        public float OffsetNormBeforeResize;
+        public ImGuiOldColumnFlags Flags;
+        public ImRect ClipRect;
+    }
+    public unsafe partial struct ImGuiOldColumnDataPtr
+    {
+        public ImGuiOldColumnData* NativePtr { get; }
+        public ImGuiOldColumnDataPtr(ImGuiOldColumnData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiOldColumnDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiOldColumnData*)nativePtr;
+        public static implicit operator ImGuiOldColumnDataPtr(ImGuiOldColumnData* nativePtr) => new ImGuiOldColumnDataPtr(nativePtr);
+        public static implicit operator ImGuiOldColumnData* (ImGuiOldColumnDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiOldColumnDataPtr(IntPtr nativePtr) => new ImGuiOldColumnDataPtr(nativePtr);
+        public ref float OffsetNorm => ref Unsafe.AsRef<float>(&NativePtr->OffsetNorm);
+        public ref float OffsetNormBeforeResize => ref Unsafe.AsRef<float>(&NativePtr->OffsetNormBeforeResize);
+        public ref ImGuiOldColumnFlags Flags => ref Unsafe.AsRef<ImGuiOldColumnFlags>(&NativePtr->Flags);
+        public ref ImRect ClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ClipRect);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiOldColumnData_destroy((ImGuiOldColumnData*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiOldColumnFlags.gen.cs

@@ -0,0 +1,13 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiOldColumnFlags
+    {
+        None = 0,
+        NoBorder = 1,
+        NoResize = 2,
+        NoPreserveWidths = 4,
+        NoForceWithinWindow = 8,
+        GrowParentContentsSize = 16,
+    }
+}

src/ImGui.NET/Generated/ImGuiOldColumns.gen.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiOldColumns
+    {
+        public uint ID;
+        public ImGuiOldColumnFlags Flags;
+        public byte IsFirstFrame;
+        public byte IsBeingResized;
+        public int Current;
+        public int Count;
+        public float OffMinX;
+        public float OffMaxX;
+        public float LineMinY;
+        public float LineMaxY;
+        public float HostCursorPosY;
+        public float HostCursorMaxPosX;
+        public ImRect HostInitialClipRect;
+        public ImRect HostBackupClipRect;
+        public ImRect HostBackupParentWorkRect;
+        public ImVector Columns;
+        public ImDrawListSplitter Splitter;
+    }
+    public unsafe partial struct ImGuiOldColumnsPtr
+    {
+        public ImGuiOldColumns* NativePtr { get; }
+        public ImGuiOldColumnsPtr(ImGuiOldColumns* nativePtr) => NativePtr = nativePtr;
+        public ImGuiOldColumnsPtr(IntPtr nativePtr) => NativePtr = (ImGuiOldColumns*)nativePtr;
+        public static implicit operator ImGuiOldColumnsPtr(ImGuiOldColumns* nativePtr) => new ImGuiOldColumnsPtr(nativePtr);
+        public static implicit operator ImGuiOldColumns* (ImGuiOldColumnsPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiOldColumnsPtr(IntPtr nativePtr) => new ImGuiOldColumnsPtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref ImGuiOldColumnFlags Flags => ref Unsafe.AsRef<ImGuiOldColumnFlags>(&NativePtr->Flags);
+        public ref bool IsFirstFrame => ref Unsafe.AsRef<bool>(&NativePtr->IsFirstFrame);
+        public ref bool IsBeingResized => ref Unsafe.AsRef<bool>(&NativePtr->IsBeingResized);
+        public ref int Current => ref Unsafe.AsRef<int>(&NativePtr->Current);
+        public ref int Count => ref Unsafe.AsRef<int>(&NativePtr->Count);
+        public ref float OffMinX => ref Unsafe.AsRef<float>(&NativePtr->OffMinX);
+        public ref float OffMaxX => ref Unsafe.AsRef<float>(&NativePtr->OffMaxX);
+        public ref float LineMinY => ref Unsafe.AsRef<float>(&NativePtr->LineMinY);
+        public ref float LineMaxY => ref Unsafe.AsRef<float>(&NativePtr->LineMaxY);
+        public ref float HostCursorPosY => ref Unsafe.AsRef<float>(&NativePtr->HostCursorPosY);
+        public ref float HostCursorMaxPosX => ref Unsafe.AsRef<float>(&NativePtr->HostCursorMaxPosX);
+        public ref ImRect HostInitialClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostInitialClipRect);
+        public ref ImRect HostBackupClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupClipRect);
+        public ref ImRect HostBackupParentWorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupParentWorkRect);
+        public ImPtrVector<ImGuiOldColumnDataPtr> Columns => new ImPtrVector<ImGuiOldColumnDataPtr>(NativePtr->Columns, Unsafe.SizeOf<ImGuiOldColumnData>());
+        public ref ImDrawListSplitter Splitter => ref Unsafe.AsRef<ImDrawListSplitter>(&NativePtr->Splitter);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiOldColumns_destroy((ImGuiOldColumns*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiPlotType.gen.cs

@@ -0,0 +1,8 @@
+namespace ImGuiNET
+{
+    public enum ImGuiPlotType
+    {
+        Lines = 0,
+        Histogram = 1,
+    }
+}

src/ImGui.NET/Generated/ImGuiPopupData.gen.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiPopupData
+    {
+        public uint PopupId;
+        public ImGuiWindow* Window;
+        public ImGuiWindow* SourceWindow;
+        public int ParentNavLayer;
+        public int OpenFrameCount;
+        public uint OpenParentId;
+        public Vector2 OpenPopupPos;
+        public Vector2 OpenMousePos;
+    }
+    public unsafe partial struct ImGuiPopupDataPtr
+    {
+        public ImGuiPopupData* NativePtr { get; }
+        public ImGuiPopupDataPtr(ImGuiPopupData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiPopupDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiPopupData*)nativePtr;
+        public static implicit operator ImGuiPopupDataPtr(ImGuiPopupData* nativePtr) => new ImGuiPopupDataPtr(nativePtr);
+        public static implicit operator ImGuiPopupData* (ImGuiPopupDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiPopupDataPtr(IntPtr nativePtr) => new ImGuiPopupDataPtr(nativePtr);
+        public ref uint PopupId => ref Unsafe.AsRef<uint>(&NativePtr->PopupId);
+        public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window);
+        public ImGuiWindowPtr SourceWindow => new ImGuiWindowPtr(NativePtr->SourceWindow);
+        public ref int ParentNavLayer => ref Unsafe.AsRef<int>(&NativePtr->ParentNavLayer);
+        public ref int OpenFrameCount => ref Unsafe.AsRef<int>(&NativePtr->OpenFrameCount);
+        public ref uint OpenParentId => ref Unsafe.AsRef<uint>(&NativePtr->OpenParentId);
+        public ref Vector2 OpenPopupPos => ref Unsafe.AsRef<Vector2>(&NativePtr->OpenPopupPos);
+        public ref Vector2 OpenMousePos => ref Unsafe.AsRef<Vector2>(&NativePtr->OpenMousePos);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiPopupData_destroy((ImGuiPopupData*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiPopupPositionPolicy.gen.cs

@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    public enum ImGuiPopupPositionPolicy
+    {
+        Default = 0,
+        ComboBox = 1,
+        Tooltip = 2,
+    }
+}

src/ImGui.NET/Generated/ImGuiPtrOrIndex.gen.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiPtrOrIndex
+    {
+        public void* Ptr;
+        public int Index;
+    }
+    public unsafe partial struct ImGuiPtrOrIndexPtr
+    {
+        public ImGuiPtrOrIndex* NativePtr { get; }
+        public ImGuiPtrOrIndexPtr(ImGuiPtrOrIndex* nativePtr) => NativePtr = nativePtr;
+        public ImGuiPtrOrIndexPtr(IntPtr nativePtr) => NativePtr = (ImGuiPtrOrIndex*)nativePtr;
+        public static implicit operator ImGuiPtrOrIndexPtr(ImGuiPtrOrIndex* nativePtr) => new ImGuiPtrOrIndexPtr(nativePtr);
+        public static implicit operator ImGuiPtrOrIndex* (ImGuiPtrOrIndexPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiPtrOrIndexPtr(IntPtr nativePtr) => new ImGuiPtrOrIndexPtr(nativePtr);
+        public IntPtr Ptr { get => (IntPtr)NativePtr->Ptr; set => NativePtr->Ptr = (void*)value; }
+        public ref int Index => ref Unsafe.AsRef<int>(&NativePtr->Index);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiPtrOrIndex_destroy((ImGuiPtrOrIndex*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiScrollFlags.gen.cs

@@ -0,0 +1,17 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiScrollFlags
+    {
+        None = 0,
+        KeepVisibleEdgeX = 1,
+        KeepVisibleEdgeY = 2,
+        KeepVisibleCenterX = 4,
+        KeepVisibleCenterY = 8,
+        AlwaysCenterX = 16,
+        AlwaysCenterY = 32,
+        NoScrollParent = 64,
+        MaskX = 21,
+        MaskY = 42,
+    }
+}

src/ImGui.NET/Generated/ImGuiSelectableFlagsPrivate.gen.cs

@@ -0,0 +1,15 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiSelectableFlagsPrivate
+    {
+        ImGuiSelectableFlags_NoHoldingActiveID = 1048576,
+        ImGuiSelectableFlags_SelectOnNav = 2097152,
+        ImGuiSelectableFlags_SelectOnClick = 4194304,
+        ImGuiSelectableFlags_SelectOnRelease = 8388608,
+        ImGuiSelectableFlags_SpanAvailWidth = 16777216,
+        ImGuiSelectableFlags_DrawHoveredWhenHeld = 33554432,
+        ImGuiSelectableFlags_SetNavIdOnHover = 67108864,
+        ImGuiSelectableFlags_NoPadWithHalfSpacing = 134217728,
+    }
+}

src/ImGui.NET/Generated/ImGuiSeparatorFlags.gen.cs

@@ -0,0 +1,11 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiSeparatorFlags
+    {
+        None = 0,
+        Horizontal = 1,
+        Vertical = 2,
+        SpanAllColumns = 4,
+    }
+}

src/ImGui.NET/Generated/ImGuiSettingsHandler.gen.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiSettingsHandler
+    {
+        public byte* TypeName;
+        public uint TypeHash;
+        public IntPtr ClearAllFn;
+        public IntPtr ReadInitFn;
+        public IntPtr ReadOpenFn;
+        public IntPtr ReadLineFn;
+        public IntPtr ApplyAllFn;
+        public IntPtr WriteAllFn;
+        public void* UserData;
+    }
+    public unsafe partial struct ImGuiSettingsHandlerPtr
+    {
+        public ImGuiSettingsHandler* NativePtr { get; }
+        public ImGuiSettingsHandlerPtr(ImGuiSettingsHandler* nativePtr) => NativePtr = nativePtr;
+        public ImGuiSettingsHandlerPtr(IntPtr nativePtr) => NativePtr = (ImGuiSettingsHandler*)nativePtr;
+        public static implicit operator ImGuiSettingsHandlerPtr(ImGuiSettingsHandler* nativePtr) => new ImGuiSettingsHandlerPtr(nativePtr);
+        public static implicit operator ImGuiSettingsHandler* (ImGuiSettingsHandlerPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiSettingsHandlerPtr(IntPtr nativePtr) => new ImGuiSettingsHandlerPtr(nativePtr);
+        public NullTerminatedString TypeName => new NullTerminatedString(NativePtr->TypeName);
+        public ref uint TypeHash => ref Unsafe.AsRef<uint>(&NativePtr->TypeHash);
+        public ref IntPtr ClearAllFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ClearAllFn);
+        public ref IntPtr ReadInitFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ReadInitFn);
+        public ref IntPtr ReadOpenFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ReadOpenFn);
+        public ref IntPtr ReadLineFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ReadLineFn);
+        public ref IntPtr ApplyAllFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->ApplyAllFn);
+        public ref IntPtr WriteAllFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->WriteAllFn);
+        public IntPtr UserData { get => (IntPtr)NativePtr->UserData; set => NativePtr->UserData = (void*)value; }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiSettingsHandler_destroy((ImGuiSettingsHandler*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiShrinkWidthItem.gen.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiShrinkWidthItem
+    {
+        public int Index;
+        public float Width;
+        public float InitialWidth;
+    }
+    public unsafe partial struct ImGuiShrinkWidthItemPtr
+    {
+        public ImGuiShrinkWidthItem* NativePtr { get; }
+        public ImGuiShrinkWidthItemPtr(ImGuiShrinkWidthItem* nativePtr) => NativePtr = nativePtr;
+        public ImGuiShrinkWidthItemPtr(IntPtr nativePtr) => NativePtr = (ImGuiShrinkWidthItem*)nativePtr;
+        public static implicit operator ImGuiShrinkWidthItemPtr(ImGuiShrinkWidthItem* nativePtr) => new ImGuiShrinkWidthItemPtr(nativePtr);
+        public static implicit operator ImGuiShrinkWidthItem* (ImGuiShrinkWidthItemPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiShrinkWidthItemPtr(IntPtr nativePtr) => new ImGuiShrinkWidthItemPtr(nativePtr);
+        public ref int Index => ref Unsafe.AsRef<int>(&NativePtr->Index);
+        public ref float Width => ref Unsafe.AsRef<float>(&NativePtr->Width);
+        public ref float InitialWidth => ref Unsafe.AsRef<float>(&NativePtr->InitialWidth);
+    }
+}

src/ImGui.NET/Generated/ImGuiSliderFlagsPrivate.gen.cs

@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiSliderFlagsPrivate
+    {
+        ImGuiSliderFlags_Vertical = 1048576,
+        ImGuiSliderFlags_ReadOnly = 2097152,
+    }
+}

src/ImGui.NET/Generated/ImGuiStackLevelInfo.gen.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiStackLevelInfo
+    {
+        public uint ID;
+        public sbyte QueryFrameCount;
+        public byte QuerySuccess;
+        public ImGuiDataType DataType;
+        public fixed byte Desc[57];
+    }
+    public unsafe partial struct ImGuiStackLevelInfoPtr
+    {
+        public ImGuiStackLevelInfo* NativePtr { get; }
+        public ImGuiStackLevelInfoPtr(ImGuiStackLevelInfo* nativePtr) => NativePtr = nativePtr;
+        public ImGuiStackLevelInfoPtr(IntPtr nativePtr) => NativePtr = (ImGuiStackLevelInfo*)nativePtr;
+        public static implicit operator ImGuiStackLevelInfoPtr(ImGuiStackLevelInfo* nativePtr) => new ImGuiStackLevelInfoPtr(nativePtr);
+        public static implicit operator ImGuiStackLevelInfo* (ImGuiStackLevelInfoPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiStackLevelInfoPtr(IntPtr nativePtr) => new ImGuiStackLevelInfoPtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref sbyte QueryFrameCount => ref Unsafe.AsRef<sbyte>(&NativePtr->QueryFrameCount);
+        public ref bool QuerySuccess => ref Unsafe.AsRef<bool>(&NativePtr->QuerySuccess);
+        public ref ImGuiDataType DataType => ref Unsafe.AsRef<ImGuiDataType>(&NativePtr->DataType);
+        public RangeAccessor<byte> Desc => new RangeAccessor<byte>(NativePtr->Desc, 57);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiStackLevelInfo_destroy((ImGuiStackLevelInfo*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiStackSizes.gen.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiStackSizes
+    {
+        public short SizeOfIDStack;
+        public short SizeOfColorStack;
+        public short SizeOfStyleVarStack;
+        public short SizeOfFontStack;
+        public short SizeOfFocusScopeStack;
+        public short SizeOfGroupStack;
+        public short SizeOfItemFlagsStack;
+        public short SizeOfBeginPopupStack;
+        public short SizeOfDisabledStack;
+    }
+    public unsafe partial struct ImGuiStackSizesPtr
+    {
+        public ImGuiStackSizes* NativePtr { get; }
+        public ImGuiStackSizesPtr(ImGuiStackSizes* nativePtr) => NativePtr = nativePtr;
+        public ImGuiStackSizesPtr(IntPtr nativePtr) => NativePtr = (ImGuiStackSizes*)nativePtr;
+        public static implicit operator ImGuiStackSizesPtr(ImGuiStackSizes* nativePtr) => new ImGuiStackSizesPtr(nativePtr);
+        public static implicit operator ImGuiStackSizes* (ImGuiStackSizesPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiStackSizesPtr(IntPtr nativePtr) => new ImGuiStackSizesPtr(nativePtr);
+        public ref short SizeOfIDStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfIDStack);
+        public ref short SizeOfColorStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfColorStack);
+        public ref short SizeOfStyleVarStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfStyleVarStack);
+        public ref short SizeOfFontStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfFontStack);
+        public ref short SizeOfFocusScopeStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfFocusScopeStack);
+        public ref short SizeOfGroupStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfGroupStack);
+        public ref short SizeOfItemFlagsStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfItemFlagsStack);
+        public ref short SizeOfBeginPopupStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfBeginPopupStack);
+        public ref short SizeOfDisabledStack => ref Unsafe.AsRef<short>(&NativePtr->SizeOfDisabledStack);
+        public void CompareWithCurrentState()
+        {
+            ImGuiNative.ImGuiStackSizes_CompareWithCurrentState((ImGuiStackSizes*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiStackSizes_destroy((ImGuiStackSizes*)(NativePtr));
+        }
+        public void SetToCurrentState()
+        {
+            ImGuiNative.ImGuiStackSizes_SetToCurrentState((ImGuiStackSizes*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiStackTool.gen.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiStackTool
+    {
+        public int LastActiveFrame;
+        public int StackLevel;
+        public uint QueryId;
+        public ImVector Results;
+        public byte CopyToClipboardOnCtrlC;
+        public float CopyToClipboardLastTime;
+    }
+    public unsafe partial struct ImGuiStackToolPtr
+    {
+        public ImGuiStackTool* NativePtr { get; }
+        public ImGuiStackToolPtr(ImGuiStackTool* nativePtr) => NativePtr = nativePtr;
+        public ImGuiStackToolPtr(IntPtr nativePtr) => NativePtr = (ImGuiStackTool*)nativePtr;
+        public static implicit operator ImGuiStackToolPtr(ImGuiStackTool* nativePtr) => new ImGuiStackToolPtr(nativePtr);
+        public static implicit operator ImGuiStackTool* (ImGuiStackToolPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiStackToolPtr(IntPtr nativePtr) => new ImGuiStackToolPtr(nativePtr);
+        public ref int LastActiveFrame => ref Unsafe.AsRef<int>(&NativePtr->LastActiveFrame);
+        public ref int StackLevel => ref Unsafe.AsRef<int>(&NativePtr->StackLevel);
+        public ref uint QueryId => ref Unsafe.AsRef<uint>(&NativePtr->QueryId);
+        public ImPtrVector<ImGuiStackLevelInfoPtr> Results => new ImPtrVector<ImGuiStackLevelInfoPtr>(NativePtr->Results, Unsafe.SizeOf<ImGuiStackLevelInfo>());
+        public ref bool CopyToClipboardOnCtrlC => ref Unsafe.AsRef<bool>(&NativePtr->CopyToClipboardOnCtrlC);
+        public ref float CopyToClipboardLastTime => ref Unsafe.AsRef<float>(&NativePtr->CopyToClipboardLastTime);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiStackTool_destroy((ImGuiStackTool*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiTabBar.gen.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiTabBar
+    {
+        public ImVector Tabs;
+        public ImGuiTabBarFlags Flags;
+        public uint ID;
+        public uint SelectedTabId;
+        public uint NextSelectedTabId;
+        public uint VisibleTabId;
+        public int CurrFrameVisible;
+        public int PrevFrameVisible;
+        public ImRect BarRect;
+        public float CurrTabsContentsHeight;
+        public float PrevTabsContentsHeight;
+        public float WidthAllTabs;
+        public float WidthAllTabsIdeal;
+        public float ScrollingAnim;
+        public float ScrollingTarget;
+        public float ScrollingTargetDistToVisibility;
+        public float ScrollingSpeed;
+        public float ScrollingRectMinX;
+        public float ScrollingRectMaxX;
+        public uint ReorderRequestTabId;
+        public short ReorderRequestOffset;
+        public sbyte BeginCount;
+        public byte WantLayout;
+        public byte VisibleTabWasSubmitted;
+        public byte TabsAddedNew;
+        public short TabsActiveCount;
+        public short LastTabItemIdx;
+        public float ItemSpacingY;
+        public Vector2 FramePadding;
+        public Vector2 BackupCursorPos;
+        public ImGuiTextBuffer TabsNames;
+    }
+    public unsafe partial struct ImGuiTabBarPtr
+    {
+        public ImGuiTabBar* NativePtr { get; }
+        public ImGuiTabBarPtr(ImGuiTabBar* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTabBarPtr(IntPtr nativePtr) => NativePtr = (ImGuiTabBar*)nativePtr;
+        public static implicit operator ImGuiTabBarPtr(ImGuiTabBar* nativePtr) => new ImGuiTabBarPtr(nativePtr);
+        public static implicit operator ImGuiTabBar* (ImGuiTabBarPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTabBarPtr(IntPtr nativePtr) => new ImGuiTabBarPtr(nativePtr);
+        public ImPtrVector<ImGuiTabItemPtr> Tabs => new ImPtrVector<ImGuiTabItemPtr>(NativePtr->Tabs, Unsafe.SizeOf<ImGuiTabItem>());
+        public ref ImGuiTabBarFlags Flags => ref Unsafe.AsRef<ImGuiTabBarFlags>(&NativePtr->Flags);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref uint SelectedTabId => ref Unsafe.AsRef<uint>(&NativePtr->SelectedTabId);
+        public ref uint NextSelectedTabId => ref Unsafe.AsRef<uint>(&NativePtr->NextSelectedTabId);
+        public ref uint VisibleTabId => ref Unsafe.AsRef<uint>(&NativePtr->VisibleTabId);
+        public ref int CurrFrameVisible => ref Unsafe.AsRef<int>(&NativePtr->CurrFrameVisible);
+        public ref int PrevFrameVisible => ref Unsafe.AsRef<int>(&NativePtr->PrevFrameVisible);
+        public ref ImRect BarRect => ref Unsafe.AsRef<ImRect>(&NativePtr->BarRect);
+        public ref float CurrTabsContentsHeight => ref Unsafe.AsRef<float>(&NativePtr->CurrTabsContentsHeight);
+        public ref float PrevTabsContentsHeight => ref Unsafe.AsRef<float>(&NativePtr->PrevTabsContentsHeight);
+        public ref float WidthAllTabs => ref Unsafe.AsRef<float>(&NativePtr->WidthAllTabs);
+        public ref float WidthAllTabsIdeal => ref Unsafe.AsRef<float>(&NativePtr->WidthAllTabsIdeal);
+        public ref float ScrollingAnim => ref Unsafe.AsRef<float>(&NativePtr->ScrollingAnim);
+        public ref float ScrollingTarget => ref Unsafe.AsRef<float>(&NativePtr->ScrollingTarget);
+        public ref float ScrollingTargetDistToVisibility => ref Unsafe.AsRef<float>(&NativePtr->ScrollingTargetDistToVisibility);
+        public ref float ScrollingSpeed => ref Unsafe.AsRef<float>(&NativePtr->ScrollingSpeed);
+        public ref float ScrollingRectMinX => ref Unsafe.AsRef<float>(&NativePtr->ScrollingRectMinX);
+        public ref float ScrollingRectMaxX => ref Unsafe.AsRef<float>(&NativePtr->ScrollingRectMaxX);
+        public ref uint ReorderRequestTabId => ref Unsafe.AsRef<uint>(&NativePtr->ReorderRequestTabId);
+        public ref short ReorderRequestOffset => ref Unsafe.AsRef<short>(&NativePtr->ReorderRequestOffset);
+        public ref sbyte BeginCount => ref Unsafe.AsRef<sbyte>(&NativePtr->BeginCount);
+        public ref bool WantLayout => ref Unsafe.AsRef<bool>(&NativePtr->WantLayout);
+        public ref bool VisibleTabWasSubmitted => ref Unsafe.AsRef<bool>(&NativePtr->VisibleTabWasSubmitted);
+        public ref bool TabsAddedNew => ref Unsafe.AsRef<bool>(&NativePtr->TabsAddedNew);
+        public ref short TabsActiveCount => ref Unsafe.AsRef<short>(&NativePtr->TabsActiveCount);
+        public ref short LastTabItemIdx => ref Unsafe.AsRef<short>(&NativePtr->LastTabItemIdx);
+        public ref float ItemSpacingY => ref Unsafe.AsRef<float>(&NativePtr->ItemSpacingY);
+        public ref Vector2 FramePadding => ref Unsafe.AsRef<Vector2>(&NativePtr->FramePadding);
+        public ref Vector2 BackupCursorPos => ref Unsafe.AsRef<Vector2>(&NativePtr->BackupCursorPos);
+        public ref ImGuiTextBuffer TabsNames => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->TabsNames);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTabBar_destroy((ImGuiTabBar*)(NativePtr));
+        }
+        public string GetTabName(ImGuiTabItemPtr tab)
+        {
+            ImGuiTabItem* native_tab = tab.NativePtr;
+            byte* ret = ImGuiNative.ImGuiTabBar_GetTabName((ImGuiTabBar*)(NativePtr), native_tab);
+            return Util.StringFromPtr(ret);
+        }
+        public int GetTabOrder(ImGuiTabItemPtr tab)
+        {
+            ImGuiTabItem* native_tab = tab.NativePtr;
+            int ret = ImGuiNative.ImGuiTabBar_GetTabOrder((ImGuiTabBar*)(NativePtr), native_tab);
+            return ret;
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiTabBarFlagsPrivate.gen.cs

@@ -0,0 +1,10 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiTabBarFlagsPrivate
+    {
+        ImGuiTabBarFlags_DockNode = 1048576,
+        ImGuiTabBarFlags_IsFocused = 2097152,
+        ImGuiTabBarFlags_SaveSettings = 4194304,
+    }
+}

src/ImGui.NET/Generated/ImGuiTabItem.gen.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiTabItem
+    {
+        public uint ID;
+        public ImGuiTabItemFlags Flags;
+        public ImGuiWindow* Window;
+        public int LastFrameVisible;
+        public int LastFrameSelected;
+        public float Offset;
+        public float Width;
+        public float ContentWidth;
+        public float RequestedWidth;
+        public int NameOffset;
+        public short BeginOrder;
+        public short IndexDuringLayout;
+        public byte WantClose;
+    }
+    public unsafe partial struct ImGuiTabItemPtr
+    {
+        public ImGuiTabItem* NativePtr { get; }
+        public ImGuiTabItemPtr(ImGuiTabItem* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTabItemPtr(IntPtr nativePtr) => NativePtr = (ImGuiTabItem*)nativePtr;
+        public static implicit operator ImGuiTabItemPtr(ImGuiTabItem* nativePtr) => new ImGuiTabItemPtr(nativePtr);
+        public static implicit operator ImGuiTabItem* (ImGuiTabItemPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTabItemPtr(IntPtr nativePtr) => new ImGuiTabItemPtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref ImGuiTabItemFlags Flags => ref Unsafe.AsRef<ImGuiTabItemFlags>(&NativePtr->Flags);
+        public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window);
+        public ref int LastFrameVisible => ref Unsafe.AsRef<int>(&NativePtr->LastFrameVisible);
+        public ref int LastFrameSelected => ref Unsafe.AsRef<int>(&NativePtr->LastFrameSelected);
+        public ref float Offset => ref Unsafe.AsRef<float>(&NativePtr->Offset);
+        public ref float Width => ref Unsafe.AsRef<float>(&NativePtr->Width);
+        public ref float ContentWidth => ref Unsafe.AsRef<float>(&NativePtr->ContentWidth);
+        public ref float RequestedWidth => ref Unsafe.AsRef<float>(&NativePtr->RequestedWidth);
+        public ref int NameOffset => ref Unsafe.AsRef<int>(&NativePtr->NameOffset);
+        public ref short BeginOrder => ref Unsafe.AsRef<short>(&NativePtr->BeginOrder);
+        public ref short IndexDuringLayout => ref Unsafe.AsRef<short>(&NativePtr->IndexDuringLayout);
+        public ref bool WantClose => ref Unsafe.AsRef<bool>(&NativePtr->WantClose);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTabItem_destroy((ImGuiTabItem*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiTabItemFlagsPrivate.gen.cs

@@ -0,0 +1,12 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiTabItemFlagsPrivate
+    {
+        ImGuiTabItemFlags_SectionMask = 192,
+        ImGuiTabItemFlags_NoCloseButton = 1048576,
+        ImGuiTabItemFlags_Button = 2097152,
+        ImGuiTabItemFlags_Unsorted = 4194304,
+        ImGuiTabItemFlags_Preview = 8388608,
+    }
+}

src/ImGui.NET/Generated/ImGuiTable.gen.cs

@@ -0,0 +1,232 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiTable
+    {
+        public uint ID;
+        public ImGuiTableFlags Flags;
+        public void* RawData;
+        public ImGuiTableTempData* TempData;
+        public (IntPtr, IntPtr) Columns;
+        public (IntPtr, IntPtr) DisplayOrderToIndex;
+        public (IntPtr, IntPtr) RowCellData;
+        public ulong EnabledMaskByDisplayOrder;
+        public ulong EnabledMaskByIndex;
+        public ulong VisibleMaskByIndex;
+        public ulong RequestOutputMaskByIndex;
+        public ImGuiTableFlags SettingsLoadedFlags;
+        public int SettingsOffset;
+        public int LastFrameActive;
+        public int ColumnsCount;
+        public int CurrentRow;
+        public int CurrentColumn;
+        public short InstanceCurrent;
+        public short InstanceInteracted;
+        public float RowPosY1;
+        public float RowPosY2;
+        public float RowMinHeight;
+        public float RowTextBaseline;
+        public float RowIndentOffsetX;
+        public ImGuiTableRowFlags RowFlags;
+        public ImGuiTableRowFlags LastRowFlags;
+        public int RowBgColorCounter;
+        public fixed uint RowBgColor[2];
+        public uint BorderColorStrong;
+        public uint BorderColorLight;
+        public float BorderX1;
+        public float BorderX2;
+        public float HostIndentX;
+        public float MinColumnWidth;
+        public float OuterPaddingX;
+        public float CellPaddingX;
+        public float CellPaddingY;
+        public float CellSpacingX1;
+        public float CellSpacingX2;
+        public float InnerWidth;
+        public float ColumnsGivenWidth;
+        public float ColumnsAutoFitWidth;
+        public float ColumnsStretchSumWeights;
+        public float ResizedColumnNextWidth;
+        public float ResizeLockMinContentsX2;
+        public float RefScale;
+        public ImRect OuterRect;
+        public ImRect InnerRect;
+        public ImRect WorkRect;
+        public ImRect InnerClipRect;
+        public ImRect BgClipRect;
+        public ImRect Bg0ClipRectForDrawCmd;
+        public ImRect Bg2ClipRectForDrawCmd;
+        public ImRect HostClipRect;
+        public ImRect HostBackupInnerClipRect;
+        public ImGuiWindow* OuterWindow;
+        public ImGuiWindow* InnerWindow;
+        public ImGuiTextBuffer ColumnsNames;
+        public ImDrawListSplitter* DrawSplitter;
+        public ImGuiTableInstanceData InstanceDataFirst;
+        public ImVector InstanceDataExtra;
+        public ImGuiTableColumnSortSpecs SortSpecsSingle;
+        public ImVector SortSpecsMulti;
+        public ImGuiTableSortSpecs SortSpecs;
+        public sbyte SortSpecsCount;
+        public sbyte ColumnsEnabledCount;
+        public sbyte ColumnsEnabledFixedCount;
+        public sbyte DeclColumnsCount;
+        public sbyte HoveredColumnBody;
+        public sbyte HoveredColumnBorder;
+        public sbyte AutoFitSingleColumn;
+        public sbyte ResizedColumn;
+        public sbyte LastResizedColumn;
+        public sbyte HeldHeaderColumn;
+        public sbyte ReorderColumn;
+        public sbyte ReorderColumnDir;
+        public sbyte LeftMostEnabledColumn;
+        public sbyte RightMostEnabledColumn;
+        public sbyte LeftMostStretchedColumn;
+        public sbyte RightMostStretchedColumn;
+        public sbyte ContextPopupColumn;
+        public sbyte FreezeRowsRequest;
+        public sbyte FreezeRowsCount;
+        public sbyte FreezeColumnsRequest;
+        public sbyte FreezeColumnsCount;
+        public sbyte RowCellDataCurrent;
+        public byte DummyDrawChannel;
+        public byte Bg2DrawChannelCurrent;
+        public byte Bg2DrawChannelUnfrozen;
+        public byte IsLayoutLocked;
+        public byte IsInsideRow;
+        public byte IsInitializing;
+        public byte IsSortSpecsDirty;
+        public byte IsUsingHeaders;
+        public byte IsContextPopupOpen;
+        public byte IsSettingsRequestLoad;
+        public byte IsSettingsDirty;
+        public byte IsDefaultDisplayOrder;
+        public byte IsResetAllRequest;
+        public byte IsResetDisplayOrderRequest;
+        public byte IsUnfrozenRows;
+        public byte IsDefaultSizingPolicy;
+        public byte MemoryCompacted;
+        public byte HostSkipItems;
+    }
+    public unsafe partial struct ImGuiTablePtr
+    {
+        public ImGuiTable* NativePtr { get; }
+        public ImGuiTablePtr(ImGuiTable* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTablePtr(IntPtr nativePtr) => NativePtr = (ImGuiTable*)nativePtr;
+        public static implicit operator ImGuiTablePtr(ImGuiTable* nativePtr) => new ImGuiTablePtr(nativePtr);
+        public static implicit operator ImGuiTable* (ImGuiTablePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTablePtr(IntPtr nativePtr) => new ImGuiTablePtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref ImGuiTableFlags Flags => ref Unsafe.AsRef<ImGuiTableFlags>(&NativePtr->Flags);
+        public IntPtr RawData { get => (IntPtr)NativePtr->RawData; set => NativePtr->RawData = (void*)value; }
+        public ImGuiTableTempDataPtr TempData => new ImGuiTableTempDataPtr(NativePtr->TempData);
+        public ref (IntPtr, IntPtr) Columns => ref Unsafe.AsRef<(IntPtr, IntPtr)>(&NativePtr->Columns);
+        public ref (IntPtr, IntPtr) DisplayOrderToIndex => ref Unsafe.AsRef<(IntPtr, IntPtr)>(&NativePtr->DisplayOrderToIndex);
+        public ref (IntPtr, IntPtr) RowCellData => ref Unsafe.AsRef<(IntPtr, IntPtr)>(&NativePtr->RowCellData);
+        public ref ulong EnabledMaskByDisplayOrder => ref Unsafe.AsRef<ulong>(&NativePtr->EnabledMaskByDisplayOrder);
+        public ref ulong EnabledMaskByIndex => ref Unsafe.AsRef<ulong>(&NativePtr->EnabledMaskByIndex);
+        public ref ulong VisibleMaskByIndex => ref Unsafe.AsRef<ulong>(&NativePtr->VisibleMaskByIndex);
+        public ref ulong RequestOutputMaskByIndex => ref Unsafe.AsRef<ulong>(&NativePtr->RequestOutputMaskByIndex);
+        public ref ImGuiTableFlags SettingsLoadedFlags => ref Unsafe.AsRef<ImGuiTableFlags>(&NativePtr->SettingsLoadedFlags);
+        public ref int SettingsOffset => ref Unsafe.AsRef<int>(&NativePtr->SettingsOffset);
+        public ref int LastFrameActive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameActive);
+        public ref int ColumnsCount => ref Unsafe.AsRef<int>(&NativePtr->ColumnsCount);
+        public ref int CurrentRow => ref Unsafe.AsRef<int>(&NativePtr->CurrentRow);
+        public ref int CurrentColumn => ref Unsafe.AsRef<int>(&NativePtr->CurrentColumn);
+        public ref short InstanceCurrent => ref Unsafe.AsRef<short>(&NativePtr->InstanceCurrent);
+        public ref short InstanceInteracted => ref Unsafe.AsRef<short>(&NativePtr->InstanceInteracted);
+        public ref float RowPosY1 => ref Unsafe.AsRef<float>(&NativePtr->RowPosY1);
+        public ref float RowPosY2 => ref Unsafe.AsRef<float>(&NativePtr->RowPosY2);
+        public ref float RowMinHeight => ref Unsafe.AsRef<float>(&NativePtr->RowMinHeight);
+        public ref float RowTextBaseline => ref Unsafe.AsRef<float>(&NativePtr->RowTextBaseline);
+        public ref float RowIndentOffsetX => ref Unsafe.AsRef<float>(&NativePtr->RowIndentOffsetX);
+        public ref ImGuiTableRowFlags RowFlags => ref Unsafe.AsRef<ImGuiTableRowFlags>(&NativePtr->RowFlags);
+        public ref ImGuiTableRowFlags LastRowFlags => ref Unsafe.AsRef<ImGuiTableRowFlags>(&NativePtr->LastRowFlags);
+        public ref int RowBgColorCounter => ref Unsafe.AsRef<int>(&NativePtr->RowBgColorCounter);
+        public RangeAccessor<uint> RowBgColor => new RangeAccessor<uint>(NativePtr->RowBgColor, 2);
+        public ref uint BorderColorStrong => ref Unsafe.AsRef<uint>(&NativePtr->BorderColorStrong);
+        public ref uint BorderColorLight => ref Unsafe.AsRef<uint>(&NativePtr->BorderColorLight);
+        public ref float BorderX1 => ref Unsafe.AsRef<float>(&NativePtr->BorderX1);
+        public ref float BorderX2 => ref Unsafe.AsRef<float>(&NativePtr->BorderX2);
+        public ref float HostIndentX => ref Unsafe.AsRef<float>(&NativePtr->HostIndentX);
+        public ref float MinColumnWidth => ref Unsafe.AsRef<float>(&NativePtr->MinColumnWidth);
+        public ref float OuterPaddingX => ref Unsafe.AsRef<float>(&NativePtr->OuterPaddingX);
+        public ref float CellPaddingX => ref Unsafe.AsRef<float>(&NativePtr->CellPaddingX);
+        public ref float CellPaddingY => ref Unsafe.AsRef<float>(&NativePtr->CellPaddingY);
+        public ref float CellSpacingX1 => ref Unsafe.AsRef<float>(&NativePtr->CellSpacingX1);
+        public ref float CellSpacingX2 => ref Unsafe.AsRef<float>(&NativePtr->CellSpacingX2);
+        public ref float InnerWidth => ref Unsafe.AsRef<float>(&NativePtr->InnerWidth);
+        public ref float ColumnsGivenWidth => ref Unsafe.AsRef<float>(&NativePtr->ColumnsGivenWidth);
+        public ref float ColumnsAutoFitWidth => ref Unsafe.AsRef<float>(&NativePtr->ColumnsAutoFitWidth);
+        public ref float ColumnsStretchSumWeights => ref Unsafe.AsRef<float>(&NativePtr->ColumnsStretchSumWeights);
+        public ref float ResizedColumnNextWidth => ref Unsafe.AsRef<float>(&NativePtr->ResizedColumnNextWidth);
+        public ref float ResizeLockMinContentsX2 => ref Unsafe.AsRef<float>(&NativePtr->ResizeLockMinContentsX2);
+        public ref float RefScale => ref Unsafe.AsRef<float>(&NativePtr->RefScale);
+        public ref ImRect OuterRect => ref Unsafe.AsRef<ImRect>(&NativePtr->OuterRect);
+        public ref ImRect InnerRect => ref Unsafe.AsRef<ImRect>(&NativePtr->InnerRect);
+        public ref ImRect WorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->WorkRect);
+        public ref ImRect InnerClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->InnerClipRect);
+        public ref ImRect BgClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->BgClipRect);
+        public ref ImRect Bg0ClipRectForDrawCmd => ref Unsafe.AsRef<ImRect>(&NativePtr->Bg0ClipRectForDrawCmd);
+        public ref ImRect Bg2ClipRectForDrawCmd => ref Unsafe.AsRef<ImRect>(&NativePtr->Bg2ClipRectForDrawCmd);
+        public ref ImRect HostClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostClipRect);
+        public ref ImRect HostBackupInnerClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupInnerClipRect);
+        public ImGuiWindowPtr OuterWindow => new ImGuiWindowPtr(NativePtr->OuterWindow);
+        public ImGuiWindowPtr InnerWindow => new ImGuiWindowPtr(NativePtr->InnerWindow);
+        public ref ImGuiTextBuffer ColumnsNames => ref Unsafe.AsRef<ImGuiTextBuffer>(&NativePtr->ColumnsNames);
+        public ImDrawListSplitterPtr DrawSplitter => new ImDrawListSplitterPtr(NativePtr->DrawSplitter);
+        public ref ImGuiTableInstanceData InstanceDataFirst => ref Unsafe.AsRef<ImGuiTableInstanceData>(&NativePtr->InstanceDataFirst);
+        public ImPtrVector<ImGuiTableInstanceDataPtr> InstanceDataExtra => new ImPtrVector<ImGuiTableInstanceDataPtr>(NativePtr->InstanceDataExtra, Unsafe.SizeOf<ImGuiTableInstanceData>());
+        public ref ImGuiTableColumnSortSpecs SortSpecsSingle => ref Unsafe.AsRef<ImGuiTableColumnSortSpecs>(&NativePtr->SortSpecsSingle);
+        public ImPtrVector<ImGuiTableColumnSortSpecsPtr> SortSpecsMulti => new ImPtrVector<ImGuiTableColumnSortSpecsPtr>(NativePtr->SortSpecsMulti, Unsafe.SizeOf<ImGuiTableColumnSortSpecs>());
+        public ref ImGuiTableSortSpecs SortSpecs => ref Unsafe.AsRef<ImGuiTableSortSpecs>(&NativePtr->SortSpecs);
+        public ref sbyte SortSpecsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->SortSpecsCount);
+        public ref sbyte ColumnsEnabledCount => ref Unsafe.AsRef<sbyte>(&NativePtr->ColumnsEnabledCount);
+        public ref sbyte ColumnsEnabledFixedCount => ref Unsafe.AsRef<sbyte>(&NativePtr->ColumnsEnabledFixedCount);
+        public ref sbyte DeclColumnsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->DeclColumnsCount);
+        public ref sbyte HoveredColumnBody => ref Unsafe.AsRef<sbyte>(&NativePtr->HoveredColumnBody);
+        public ref sbyte HoveredColumnBorder => ref Unsafe.AsRef<sbyte>(&NativePtr->HoveredColumnBorder);
+        public ref sbyte AutoFitSingleColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->AutoFitSingleColumn);
+        public ref sbyte ResizedColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->ResizedColumn);
+        public ref sbyte LastResizedColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->LastResizedColumn);
+        public ref sbyte HeldHeaderColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->HeldHeaderColumn);
+        public ref sbyte ReorderColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->ReorderColumn);
+        public ref sbyte ReorderColumnDir => ref Unsafe.AsRef<sbyte>(&NativePtr->ReorderColumnDir);
+        public ref sbyte LeftMostEnabledColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->LeftMostEnabledColumn);
+        public ref sbyte RightMostEnabledColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->RightMostEnabledColumn);
+        public ref sbyte LeftMostStretchedColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->LeftMostStretchedColumn);
+        public ref sbyte RightMostStretchedColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->RightMostStretchedColumn);
+        public ref sbyte ContextPopupColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->ContextPopupColumn);
+        public ref sbyte FreezeRowsRequest => ref Unsafe.AsRef<sbyte>(&NativePtr->FreezeRowsRequest);
+        public ref sbyte FreezeRowsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->FreezeRowsCount);
+        public ref sbyte FreezeColumnsRequest => ref Unsafe.AsRef<sbyte>(&NativePtr->FreezeColumnsRequest);
+        public ref sbyte FreezeColumnsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->FreezeColumnsCount);
+        public ref sbyte RowCellDataCurrent => ref Unsafe.AsRef<sbyte>(&NativePtr->RowCellDataCurrent);
+        public ref byte DummyDrawChannel => ref Unsafe.AsRef<byte>(&NativePtr->DummyDrawChannel);
+        public ref byte Bg2DrawChannelCurrent => ref Unsafe.AsRef<byte>(&NativePtr->Bg2DrawChannelCurrent);
+        public ref byte Bg2DrawChannelUnfrozen => ref Unsafe.AsRef<byte>(&NativePtr->Bg2DrawChannelUnfrozen);
+        public ref bool IsLayoutLocked => ref Unsafe.AsRef<bool>(&NativePtr->IsLayoutLocked);
+        public ref bool IsInsideRow => ref Unsafe.AsRef<bool>(&NativePtr->IsInsideRow);
+        public ref bool IsInitializing => ref Unsafe.AsRef<bool>(&NativePtr->IsInitializing);
+        public ref bool IsSortSpecsDirty => ref Unsafe.AsRef<bool>(&NativePtr->IsSortSpecsDirty);
+        public ref bool IsUsingHeaders => ref Unsafe.AsRef<bool>(&NativePtr->IsUsingHeaders);
+        public ref bool IsContextPopupOpen => ref Unsafe.AsRef<bool>(&NativePtr->IsContextPopupOpen);
+        public ref bool IsSettingsRequestLoad => ref Unsafe.AsRef<bool>(&NativePtr->IsSettingsRequestLoad);
+        public ref bool IsSettingsDirty => ref Unsafe.AsRef<bool>(&NativePtr->IsSettingsDirty);
+        public ref bool IsDefaultDisplayOrder => ref Unsafe.AsRef<bool>(&NativePtr->IsDefaultDisplayOrder);
+        public ref bool IsResetAllRequest => ref Unsafe.AsRef<bool>(&NativePtr->IsResetAllRequest);
+        public ref bool IsResetDisplayOrderRequest => ref Unsafe.AsRef<bool>(&NativePtr->IsResetDisplayOrderRequest);
+        public ref bool IsUnfrozenRows => ref Unsafe.AsRef<bool>(&NativePtr->IsUnfrozenRows);
+        public ref bool IsDefaultSizingPolicy => ref Unsafe.AsRef<bool>(&NativePtr->IsDefaultSizingPolicy);
+        public ref bool MemoryCompacted => ref Unsafe.AsRef<bool>(&NativePtr->MemoryCompacted);
+        public ref bool HostSkipItems => ref Unsafe.AsRef<bool>(&NativePtr->HostSkipItems);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTable_destroy((ImGuiTable*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiTableCellData.gen.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiTableCellData
+    {
+        public uint BgColor;
+        public sbyte Column;
+    }
+    public unsafe partial struct ImGuiTableCellDataPtr
+    {
+        public ImGuiTableCellData* NativePtr { get; }
+        public ImGuiTableCellDataPtr(ImGuiTableCellData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTableCellDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableCellData*)nativePtr;
+        public static implicit operator ImGuiTableCellDataPtr(ImGuiTableCellData* nativePtr) => new ImGuiTableCellDataPtr(nativePtr);
+        public static implicit operator ImGuiTableCellData* (ImGuiTableCellDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTableCellDataPtr(IntPtr nativePtr) => new ImGuiTableCellDataPtr(nativePtr);
+        public ref uint BgColor => ref Unsafe.AsRef<uint>(&NativePtr->BgColor);
+        public ref sbyte Column => ref Unsafe.AsRef<sbyte>(&NativePtr->Column);
+    }
+}

src/ImGui.NET/Generated/ImGuiTableColumn.gen.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiTableColumn
+    {
+        public ImGuiTableColumnFlags Flags;
+        public float WidthGiven;
+        public float MinX;
+        public float MaxX;
+        public float WidthRequest;
+        public float WidthAuto;
+        public float StretchWeight;
+        public float InitStretchWeightOrWidth;
+        public ImRect ClipRect;
+        public uint UserID;
+        public float WorkMinX;
+        public float WorkMaxX;
+        public float ItemWidth;
+        public float ContentMaxXFrozen;
+        public float ContentMaxXUnfrozen;
+        public float ContentMaxXHeadersUsed;
+        public float ContentMaxXHeadersIdeal;
+        public short NameOffset;
+        public sbyte DisplayOrder;
+        public sbyte IndexWithinEnabledSet;
+        public sbyte PrevEnabledColumn;
+        public sbyte NextEnabledColumn;
+        public sbyte SortOrder;
+        public byte DrawChannelCurrent;
+        public byte DrawChannelFrozen;
+        public byte DrawChannelUnfrozen;
+        public byte IsEnabled;
+        public byte IsUserEnabled;
+        public byte IsUserEnabledNextFrame;
+        public byte IsVisibleX;
+        public byte IsVisibleY;
+        public byte IsRequestOutput;
+        public byte IsSkipItems;
+        public byte IsPreserveWidthAuto;
+        public sbyte NavLayerCurrent;
+        public byte AutoFitQueue;
+        public byte CannotSkipItemsQueue;
+        public byte SortDirection;
+        public byte SortDirectionsAvailCount;
+        public byte SortDirectionsAvailMask;
+        public byte SortDirectionsAvailList;
+    }
+    public unsafe partial struct ImGuiTableColumnPtr
+    {
+        public ImGuiTableColumn* NativePtr { get; }
+        public ImGuiTableColumnPtr(ImGuiTableColumn* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTableColumnPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableColumn*)nativePtr;
+        public static implicit operator ImGuiTableColumnPtr(ImGuiTableColumn* nativePtr) => new ImGuiTableColumnPtr(nativePtr);
+        public static implicit operator ImGuiTableColumn* (ImGuiTableColumnPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTableColumnPtr(IntPtr nativePtr) => new ImGuiTableColumnPtr(nativePtr);
+        public ref ImGuiTableColumnFlags Flags => ref Unsafe.AsRef<ImGuiTableColumnFlags>(&NativePtr->Flags);
+        public ref float WidthGiven => ref Unsafe.AsRef<float>(&NativePtr->WidthGiven);
+        public ref float MinX => ref Unsafe.AsRef<float>(&NativePtr->MinX);
+        public ref float MaxX => ref Unsafe.AsRef<float>(&NativePtr->MaxX);
+        public ref float WidthRequest => ref Unsafe.AsRef<float>(&NativePtr->WidthRequest);
+        public ref float WidthAuto => ref Unsafe.AsRef<float>(&NativePtr->WidthAuto);
+        public ref float StretchWeight => ref Unsafe.AsRef<float>(&NativePtr->StretchWeight);
+        public ref float InitStretchWeightOrWidth => ref Unsafe.AsRef<float>(&NativePtr->InitStretchWeightOrWidth);
+        public ref ImRect ClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ClipRect);
+        public ref uint UserID => ref Unsafe.AsRef<uint>(&NativePtr->UserID);
+        public ref float WorkMinX => ref Unsafe.AsRef<float>(&NativePtr->WorkMinX);
+        public ref float WorkMaxX => ref Unsafe.AsRef<float>(&NativePtr->WorkMaxX);
+        public ref float ItemWidth => ref Unsafe.AsRef<float>(&NativePtr->ItemWidth);
+        public ref float ContentMaxXFrozen => ref Unsafe.AsRef<float>(&NativePtr->ContentMaxXFrozen);
+        public ref float ContentMaxXUnfrozen => ref Unsafe.AsRef<float>(&NativePtr->ContentMaxXUnfrozen);
+        public ref float ContentMaxXHeadersUsed => ref Unsafe.AsRef<float>(&NativePtr->ContentMaxXHeadersUsed);
+        public ref float ContentMaxXHeadersIdeal => ref Unsafe.AsRef<float>(&NativePtr->ContentMaxXHeadersIdeal);
+        public ref short NameOffset => ref Unsafe.AsRef<short>(&NativePtr->NameOffset);
+        public ref sbyte DisplayOrder => ref Unsafe.AsRef<sbyte>(&NativePtr->DisplayOrder);
+        public ref sbyte IndexWithinEnabledSet => ref Unsafe.AsRef<sbyte>(&NativePtr->IndexWithinEnabledSet);
+        public ref sbyte PrevEnabledColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->PrevEnabledColumn);
+        public ref sbyte NextEnabledColumn => ref Unsafe.AsRef<sbyte>(&NativePtr->NextEnabledColumn);
+        public ref sbyte SortOrder => ref Unsafe.AsRef<sbyte>(&NativePtr->SortOrder);
+        public ref byte DrawChannelCurrent => ref Unsafe.AsRef<byte>(&NativePtr->DrawChannelCurrent);
+        public ref byte DrawChannelFrozen => ref Unsafe.AsRef<byte>(&NativePtr->DrawChannelFrozen);
+        public ref byte DrawChannelUnfrozen => ref Unsafe.AsRef<byte>(&NativePtr->DrawChannelUnfrozen);
+        public ref bool IsEnabled => ref Unsafe.AsRef<bool>(&NativePtr->IsEnabled);
+        public ref bool IsUserEnabled => ref Unsafe.AsRef<bool>(&NativePtr->IsUserEnabled);
+        public ref bool IsUserEnabledNextFrame => ref Unsafe.AsRef<bool>(&NativePtr->IsUserEnabledNextFrame);
+        public ref bool IsVisibleX => ref Unsafe.AsRef<bool>(&NativePtr->IsVisibleX);
+        public ref bool IsVisibleY => ref Unsafe.AsRef<bool>(&NativePtr->IsVisibleY);
+        public ref bool IsRequestOutput => ref Unsafe.AsRef<bool>(&NativePtr->IsRequestOutput);
+        public ref bool IsSkipItems => ref Unsafe.AsRef<bool>(&NativePtr->IsSkipItems);
+        public ref bool IsPreserveWidthAuto => ref Unsafe.AsRef<bool>(&NativePtr->IsPreserveWidthAuto);
+        public ref sbyte NavLayerCurrent => ref Unsafe.AsRef<sbyte>(&NativePtr->NavLayerCurrent);
+        public ref byte AutoFitQueue => ref Unsafe.AsRef<byte>(&NativePtr->AutoFitQueue);
+        public ref byte CannotSkipItemsQueue => ref Unsafe.AsRef<byte>(&NativePtr->CannotSkipItemsQueue);
+        public ref byte SortDirection => ref Unsafe.AsRef<byte>(&NativePtr->SortDirection);
+        public ref byte SortDirectionsAvailCount => ref Unsafe.AsRef<byte>(&NativePtr->SortDirectionsAvailCount);
+        public ref byte SortDirectionsAvailMask => ref Unsafe.AsRef<byte>(&NativePtr->SortDirectionsAvailMask);
+        public ref byte SortDirectionsAvailList => ref Unsafe.AsRef<byte>(&NativePtr->SortDirectionsAvailList);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTableColumn_destroy((ImGuiTableColumn*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiTableColumnSettings.gen.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiTableColumnSettings
+    {
+        public float WidthOrWeight;
+        public uint UserID;
+        public sbyte Index;
+        public sbyte DisplayOrder;
+        public sbyte SortOrder;
+        public byte SortDirection;
+        public byte IsEnabled;
+        public byte IsStretch;
+    }
+    public unsafe partial struct ImGuiTableColumnSettingsPtr
+    {
+        public ImGuiTableColumnSettings* NativePtr { get; }
+        public ImGuiTableColumnSettingsPtr(ImGuiTableColumnSettings* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTableColumnSettingsPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableColumnSettings*)nativePtr;
+        public static implicit operator ImGuiTableColumnSettingsPtr(ImGuiTableColumnSettings* nativePtr) => new ImGuiTableColumnSettingsPtr(nativePtr);
+        public static implicit operator ImGuiTableColumnSettings* (ImGuiTableColumnSettingsPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTableColumnSettingsPtr(IntPtr nativePtr) => new ImGuiTableColumnSettingsPtr(nativePtr);
+        public ref float WidthOrWeight => ref Unsafe.AsRef<float>(&NativePtr->WidthOrWeight);
+        public ref uint UserID => ref Unsafe.AsRef<uint>(&NativePtr->UserID);
+        public ref sbyte Index => ref Unsafe.AsRef<sbyte>(&NativePtr->Index);
+        public ref sbyte DisplayOrder => ref Unsafe.AsRef<sbyte>(&NativePtr->DisplayOrder);
+        public ref sbyte SortOrder => ref Unsafe.AsRef<sbyte>(&NativePtr->SortOrder);
+        public ref byte SortDirection => ref Unsafe.AsRef<byte>(&NativePtr->SortDirection);
+        public ref byte IsEnabled => ref Unsafe.AsRef<byte>(&NativePtr->IsEnabled);
+        public ref byte IsStretch => ref Unsafe.AsRef<byte>(&NativePtr->IsStretch);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTableColumnSettings_destroy((ImGuiTableColumnSettings*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiTableInstanceData.gen.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiTableInstanceData
+    {
+        public float LastOuterHeight;
+        public float LastFirstRowHeight;
+    }
+    public unsafe partial struct ImGuiTableInstanceDataPtr
+    {
+        public ImGuiTableInstanceData* NativePtr { get; }
+        public ImGuiTableInstanceDataPtr(ImGuiTableInstanceData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTableInstanceDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableInstanceData*)nativePtr;
+        public static implicit operator ImGuiTableInstanceDataPtr(ImGuiTableInstanceData* nativePtr) => new ImGuiTableInstanceDataPtr(nativePtr);
+        public static implicit operator ImGuiTableInstanceData* (ImGuiTableInstanceDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTableInstanceDataPtr(IntPtr nativePtr) => new ImGuiTableInstanceDataPtr(nativePtr);
+        public ref float LastOuterHeight => ref Unsafe.AsRef<float>(&NativePtr->LastOuterHeight);
+        public ref float LastFirstRowHeight => ref Unsafe.AsRef<float>(&NativePtr->LastFirstRowHeight);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTableInstanceData_destroy((ImGuiTableInstanceData*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiTableSettings.gen.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiTableSettings
+    {
+        public uint ID;
+        public ImGuiTableFlags SaveFlags;
+        public float RefScale;
+        public sbyte ColumnsCount;
+        public sbyte ColumnsCountMax;
+        public byte WantApply;
+    }
+    public unsafe partial struct ImGuiTableSettingsPtr
+    {
+        public ImGuiTableSettings* NativePtr { get; }
+        public ImGuiTableSettingsPtr(ImGuiTableSettings* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTableSettingsPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableSettings*)nativePtr;
+        public static implicit operator ImGuiTableSettingsPtr(ImGuiTableSettings* nativePtr) => new ImGuiTableSettingsPtr(nativePtr);
+        public static implicit operator ImGuiTableSettings* (ImGuiTableSettingsPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTableSettingsPtr(IntPtr nativePtr) => new ImGuiTableSettingsPtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref ImGuiTableFlags SaveFlags => ref Unsafe.AsRef<ImGuiTableFlags>(&NativePtr->SaveFlags);
+        public ref float RefScale => ref Unsafe.AsRef<float>(&NativePtr->RefScale);
+        public ref sbyte ColumnsCount => ref Unsafe.AsRef<sbyte>(&NativePtr->ColumnsCount);
+        public ref sbyte ColumnsCountMax => ref Unsafe.AsRef<sbyte>(&NativePtr->ColumnsCountMax);
+        public ref bool WantApply => ref Unsafe.AsRef<bool>(&NativePtr->WantApply);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTableSettings_destroy((ImGuiTableSettings*)(NativePtr));
+        }
+        public ImGuiTableColumnSettingsPtr GetColumnSettings()
+        {
+            ImGuiTableColumnSettings* ret = ImGuiNative.ImGuiTableSettings_GetColumnSettings((ImGuiTableSettings*)(NativePtr));
+            return new ImGuiTableColumnSettingsPtr(ret);
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiTableTempData.gen.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiTableTempData
+    {
+        public int TableIndex;
+        public float LastTimeActive;
+        public Vector2 UserOuterSize;
+        public ImDrawListSplitter DrawSplitter;
+        public ImRect HostBackupWorkRect;
+        public ImRect HostBackupParentWorkRect;
+        public Vector2 HostBackupPrevLineSize;
+        public Vector2 HostBackupCurrLineSize;
+        public Vector2 HostBackupCursorMaxPos;
+        public ImVec1 HostBackupColumnsOffset;
+        public float HostBackupItemWidth;
+        public int HostBackupItemWidthStackSize;
+    }
+    public unsafe partial struct ImGuiTableTempDataPtr
+    {
+        public ImGuiTableTempData* NativePtr { get; }
+        public ImGuiTableTempDataPtr(ImGuiTableTempData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiTableTempDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiTableTempData*)nativePtr;
+        public static implicit operator ImGuiTableTempDataPtr(ImGuiTableTempData* nativePtr) => new ImGuiTableTempDataPtr(nativePtr);
+        public static implicit operator ImGuiTableTempData* (ImGuiTableTempDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiTableTempDataPtr(IntPtr nativePtr) => new ImGuiTableTempDataPtr(nativePtr);
+        public ref int TableIndex => ref Unsafe.AsRef<int>(&NativePtr->TableIndex);
+        public ref float LastTimeActive => ref Unsafe.AsRef<float>(&NativePtr->LastTimeActive);
+        public ref Vector2 UserOuterSize => ref Unsafe.AsRef<Vector2>(&NativePtr->UserOuterSize);
+        public ref ImDrawListSplitter DrawSplitter => ref Unsafe.AsRef<ImDrawListSplitter>(&NativePtr->DrawSplitter);
+        public ref ImRect HostBackupWorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupWorkRect);
+        public ref ImRect HostBackupParentWorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->HostBackupParentWorkRect);
+        public ref Vector2 HostBackupPrevLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->HostBackupPrevLineSize);
+        public ref Vector2 HostBackupCurrLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->HostBackupCurrLineSize);
+        public ref Vector2 HostBackupCursorMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->HostBackupCursorMaxPos);
+        public ref ImVec1 HostBackupColumnsOffset => ref Unsafe.AsRef<ImVec1>(&NativePtr->HostBackupColumnsOffset);
+        public ref float HostBackupItemWidth => ref Unsafe.AsRef<float>(&NativePtr->HostBackupItemWidth);
+        public ref int HostBackupItemWidthStackSize => ref Unsafe.AsRef<int>(&NativePtr->HostBackupItemWidthStackSize);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiTableTempData_destroy((ImGuiTableTempData*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiTextFlags.gen.cs

@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiTextFlags
+    {
+        None = 0,
+        NoWidthForLargeClippedText = 1,
+    }
+}

src/ImGui.NET/Generated/ImGuiTooltipFlags.gen.cs

@@ -0,0 +1,9 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiTooltipFlags
+    {
+        None = 0,
+        OverridePreviousTooltip = 1,
+    }
+}

src/ImGui.NET/Generated/ImGuiTreeNodeFlagsPrivate.gen.cs

@@ -0,0 +1,8 @@
+namespace ImGuiNET
+{
+    [System.Flags]
+    public enum ImGuiTreeNodeFlagsPrivate
+    {
+        ImGuiTreeNodeFlags_ClipLabelForTrailingButton = 1048576,
+    }
+}

src/ImGui.NET/Generated/ImGuiViewportP.gen.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiViewportP
+    {
+        public ImGuiViewport _ImGuiViewport;
+        public int Idx;
+        public int LastFrameActive;
+        public int LastFrontMostStampCount;
+        public uint LastNameHash;
+        public Vector2 LastPos;
+        public float Alpha;
+        public float LastAlpha;
+        public short PlatformMonitor;
+        public byte PlatformWindowCreated;
+        public ImGuiWindow* Window;
+        public fixed int DrawListsLastFrame[2];
+        public ImDrawList* DrawLists_0;
+        public ImDrawList* DrawLists_1;
+        public ImDrawData DrawDataP;
+        public ImDrawDataBuilder DrawDataBuilder;
+        public Vector2 LastPlatformPos;
+        public Vector2 LastPlatformSize;
+        public Vector2 LastRendererSize;
+        public Vector2 WorkOffsetMin;
+        public Vector2 WorkOffsetMax;
+        public Vector2 BuildWorkOffsetMin;
+        public Vector2 BuildWorkOffsetMax;
+    }
+    public unsafe partial struct ImGuiViewportPPtr
+    {
+        public ImGuiViewportP* NativePtr { get; }
+        public ImGuiViewportPPtr(ImGuiViewportP* nativePtr) => NativePtr = nativePtr;
+        public ImGuiViewportPPtr(IntPtr nativePtr) => NativePtr = (ImGuiViewportP*)nativePtr;
+        public static implicit operator ImGuiViewportPPtr(ImGuiViewportP* nativePtr) => new ImGuiViewportPPtr(nativePtr);
+        public static implicit operator ImGuiViewportP* (ImGuiViewportPPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiViewportPPtr(IntPtr nativePtr) => new ImGuiViewportPPtr(nativePtr);
+        public ref ImGuiViewport _ImGuiViewport => ref Unsafe.AsRef<ImGuiViewport>(&NativePtr->_ImGuiViewport);
+        public ref int Idx => ref Unsafe.AsRef<int>(&NativePtr->Idx);
+        public ref int LastFrameActive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameActive);
+        public ref int LastFrontMostStampCount => ref Unsafe.AsRef<int>(&NativePtr->LastFrontMostStampCount);
+        public ref uint LastNameHash => ref Unsafe.AsRef<uint>(&NativePtr->LastNameHash);
+        public ref Vector2 LastPos => ref Unsafe.AsRef<Vector2>(&NativePtr->LastPos);
+        public ref float Alpha => ref Unsafe.AsRef<float>(&NativePtr->Alpha);
+        public ref float LastAlpha => ref Unsafe.AsRef<float>(&NativePtr->LastAlpha);
+        public ref short PlatformMonitor => ref Unsafe.AsRef<short>(&NativePtr->PlatformMonitor);
+        public ref bool PlatformWindowCreated => ref Unsafe.AsRef<bool>(&NativePtr->PlatformWindowCreated);
+        public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window);
+        public RangeAccessor<int> DrawListsLastFrame => new RangeAccessor<int>(NativePtr->DrawListsLastFrame, 2);
+        public RangeAccessor<IntPtr> DrawLists => new RangeAccessor<IntPtr>(&NativePtr->DrawLists_0, 2);
+        public ref ImDrawData DrawDataP => ref Unsafe.AsRef<ImDrawData>(&NativePtr->DrawDataP);
+        public ref ImDrawDataBuilder DrawDataBuilder => ref Unsafe.AsRef<ImDrawDataBuilder>(&NativePtr->DrawDataBuilder);
+        public ref Vector2 LastPlatformPos => ref Unsafe.AsRef<Vector2>(&NativePtr->LastPlatformPos);
+        public ref Vector2 LastPlatformSize => ref Unsafe.AsRef<Vector2>(&NativePtr->LastPlatformSize);
+        public ref Vector2 LastRendererSize => ref Unsafe.AsRef<Vector2>(&NativePtr->LastRendererSize);
+        public ref Vector2 WorkOffsetMin => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkOffsetMin);
+        public ref Vector2 WorkOffsetMax => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkOffsetMax);
+        public ref Vector2 BuildWorkOffsetMin => ref Unsafe.AsRef<Vector2>(&NativePtr->BuildWorkOffsetMin);
+        public ref Vector2 BuildWorkOffsetMax => ref Unsafe.AsRef<Vector2>(&NativePtr->BuildWorkOffsetMax);
+        public Vector2 CalcWorkRectPos(Vector2 off_min)
+        {
+            Vector2 __retval;
+            ImGuiNative.ImGuiViewportP_CalcWorkRectPos(&__retval, (ImGuiViewportP*)(NativePtr), off_min);
+            return __retval;
+        }
+        public Vector2 CalcWorkRectSize(Vector2 off_min, Vector2 off_max)
+        {
+            Vector2 __retval;
+            ImGuiNative.ImGuiViewportP_CalcWorkRectSize(&__retval, (ImGuiViewportP*)(NativePtr), off_min, off_max);
+            return __retval;
+        }
+        public void ClearRequestFlags()
+        {
+            ImGuiNative.ImGuiViewportP_ClearRequestFlags((ImGuiViewportP*)(NativePtr));
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiViewportP_destroy((ImGuiViewportP*)(NativePtr));
+        }
+        public ImRect GetBuildWorkRect()
+        {
+            ImRect __retval;
+            ImGuiNative.ImGuiViewportP_GetBuildWorkRect(&__retval, (ImGuiViewportP*)(NativePtr));
+            return __retval;
+        }
+        public ImRect GetMainRect()
+        {
+            ImRect __retval;
+            ImGuiNative.ImGuiViewportP_GetMainRect(&__retval, (ImGuiViewportP*)(NativePtr));
+            return __retval;
+        }
+        public ImRect GetWorkRect()
+        {
+            ImRect __retval;
+            ImGuiNative.ImGuiViewportP_GetWorkRect(&__retval, (ImGuiViewportP*)(NativePtr));
+            return __retval;
+        }
+        public void UpdateWorkRect()
+        {
+            ImGuiNative.ImGuiViewportP_UpdateWorkRect((ImGuiViewportP*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiWindow.gen.cs

@@ -0,0 +1,320 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiWindow
+    {
+        public byte* Name;
+        public uint ID;
+        public ImGuiWindowFlags Flags;
+        public ImGuiWindowFlags FlagsPreviousFrame;
+        public ImGuiWindowClass WindowClass;
+        public ImGuiViewportP* Viewport;
+        public uint ViewportId;
+        public Vector2 ViewportPos;
+        public int ViewportAllowPlatformMonitorExtend;
+        public Vector2 Pos;
+        public Vector2 Size;
+        public Vector2 SizeFull;
+        public Vector2 ContentSize;
+        public Vector2 ContentSizeIdeal;
+        public Vector2 ContentSizeExplicit;
+        public Vector2 WindowPadding;
+        public float WindowRounding;
+        public float WindowBorderSize;
+        public int NameBufLen;
+        public uint MoveId;
+        public uint TabId;
+        public uint ChildId;
+        public Vector2 Scroll;
+        public Vector2 ScrollMax;
+        public Vector2 ScrollTarget;
+        public Vector2 ScrollTargetCenterRatio;
+        public Vector2 ScrollTargetEdgeSnapDist;
+        public Vector2 ScrollbarSizes;
+        public byte ScrollbarX;
+        public byte ScrollbarY;
+        public byte ViewportOwned;
+        public byte Active;
+        public byte WasActive;
+        public byte WriteAccessed;
+        public byte Collapsed;
+        public byte WantCollapseToggle;
+        public byte SkipItems;
+        public byte Appearing;
+        public byte Hidden;
+        public byte IsFallbackWindow;
+        public byte IsExplicitChild;
+        public byte HasCloseButton;
+        public sbyte ResizeBorderHeld;
+        public short BeginCount;
+        public short BeginOrderWithinParent;
+        public short BeginOrderWithinContext;
+        public short FocusOrder;
+        public uint PopupId;
+        public sbyte AutoFitFramesX;
+        public sbyte AutoFitFramesY;
+        public sbyte AutoFitChildAxises;
+        public byte AutoFitOnlyGrows;
+        public ImGuiDir AutoPosLastDirection;
+        public sbyte HiddenFramesCanSkipItems;
+        public sbyte HiddenFramesCannotSkipItems;
+        public sbyte HiddenFramesForRenderOnly;
+        public sbyte DisableInputsFrames;
+        public ImGuiCond SetWindowPosAllowFlags;
+        public ImGuiCond SetWindowSizeAllowFlags;
+        public ImGuiCond SetWindowCollapsedAllowFlags;
+        public ImGuiCond SetWindowDockAllowFlags;
+        public Vector2 SetWindowPosVal;
+        public Vector2 SetWindowPosPivot;
+        public ImVector IDStack;
+        public ImGuiWindowTempData DC;
+        public ImRect OuterRectClipped;
+        public ImRect InnerRect;
+        public ImRect InnerClipRect;
+        public ImRect WorkRect;
+        public ImRect ParentWorkRect;
+        public ImRect ClipRect;
+        public ImRect ContentRegionRect;
+        public ImVec2ih HitTestHoleSize;
+        public ImVec2ih HitTestHoleOffset;
+        public int LastFrameActive;
+        public int LastFrameJustFocused;
+        public float LastTimeActive;
+        public float ItemWidthDefault;
+        public ImGuiStorage StateStorage;
+        public ImVector ColumnsStorage;
+        public float FontWindowScale;
+        public float FontDpiScale;
+        public int SettingsOffset;
+        public ImDrawList* DrawList;
+        public ImDrawList DrawListInst;
+        public ImGuiWindow* ParentWindow;
+        public ImGuiWindow* ParentWindowInBeginStack;
+        public ImGuiWindow* RootWindow;
+        public ImGuiWindow* RootWindowPopupTree;
+        public ImGuiWindow* RootWindowDockTree;
+        public ImGuiWindow* RootWindowForTitleBarHighlight;
+        public ImGuiWindow* RootWindowForNav;
+        public ImGuiWindow* NavLastChildNavWindow;
+        public fixed uint NavLastIds[2];
+        public ImRect NavRectRel_0;
+        public ImRect NavRectRel_1;
+        public int MemoryDrawListIdxCapacity;
+        public int MemoryDrawListVtxCapacity;
+        public byte MemoryCompacted;
+        public byte DockIsActive;
+        public byte DockNodeIsVisible;
+        public byte DockTabIsVisible;
+        public byte DockTabWantClose;
+        public short DockOrder;
+        public ImGuiWindowDockStyle DockStyle;
+        public ImGuiDockNode* DockNode;
+        public ImGuiDockNode* DockNodeAsHost;
+        public uint DockId;
+        public ImGuiItemStatusFlags DockTabItemStatusFlags;
+        public ImRect DockTabItemRect;
+    }
+    public unsafe partial struct ImGuiWindowPtr
+    {
+        public ImGuiWindow* NativePtr { get; }
+        public ImGuiWindowPtr(ImGuiWindow* nativePtr) => NativePtr = nativePtr;
+        public ImGuiWindowPtr(IntPtr nativePtr) => NativePtr = (ImGuiWindow*)nativePtr;
+        public static implicit operator ImGuiWindowPtr(ImGuiWindow* nativePtr) => new ImGuiWindowPtr(nativePtr);
+        public static implicit operator ImGuiWindow* (ImGuiWindowPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiWindowPtr(IntPtr nativePtr) => new ImGuiWindowPtr(nativePtr);
+        public NullTerminatedString Name => new NullTerminatedString(NativePtr->Name);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref ImGuiWindowFlags Flags => ref Unsafe.AsRef<ImGuiWindowFlags>(&NativePtr->Flags);
+        public ref ImGuiWindowFlags FlagsPreviousFrame => ref Unsafe.AsRef<ImGuiWindowFlags>(&NativePtr->FlagsPreviousFrame);
+        public ref ImGuiWindowClass WindowClass => ref Unsafe.AsRef<ImGuiWindowClass>(&NativePtr->WindowClass);
+        public ImGuiViewportPPtr Viewport => new ImGuiViewportPPtr(NativePtr->Viewport);
+        public ref uint ViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ViewportId);
+        public ref Vector2 ViewportPos => ref Unsafe.AsRef<Vector2>(&NativePtr->ViewportPos);
+        public ref int ViewportAllowPlatformMonitorExtend => ref Unsafe.AsRef<int>(&NativePtr->ViewportAllowPlatformMonitorExtend);
+        public ref Vector2 Pos => ref Unsafe.AsRef<Vector2>(&NativePtr->Pos);
+        public ref Vector2 Size => ref Unsafe.AsRef<Vector2>(&NativePtr->Size);
+        public ref Vector2 SizeFull => ref Unsafe.AsRef<Vector2>(&NativePtr->SizeFull);
+        public ref Vector2 ContentSize => ref Unsafe.AsRef<Vector2>(&NativePtr->ContentSize);
+        public ref Vector2 ContentSizeIdeal => ref Unsafe.AsRef<Vector2>(&NativePtr->ContentSizeIdeal);
+        public ref Vector2 ContentSizeExplicit => ref Unsafe.AsRef<Vector2>(&NativePtr->ContentSizeExplicit);
+        public ref Vector2 WindowPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowPadding);
+        public ref float WindowRounding => ref Unsafe.AsRef<float>(&NativePtr->WindowRounding);
+        public ref float WindowBorderSize => ref Unsafe.AsRef<float>(&NativePtr->WindowBorderSize);
+        public ref int NameBufLen => ref Unsafe.AsRef<int>(&NativePtr->NameBufLen);
+        public ref uint MoveId => ref Unsafe.AsRef<uint>(&NativePtr->MoveId);
+        public ref uint TabId => ref Unsafe.AsRef<uint>(&NativePtr->TabId);
+        public ref uint ChildId => ref Unsafe.AsRef<uint>(&NativePtr->ChildId);
+        public ref Vector2 Scroll => ref Unsafe.AsRef<Vector2>(&NativePtr->Scroll);
+        public ref Vector2 ScrollMax => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollMax);
+        public ref Vector2 ScrollTarget => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollTarget);
+        public ref Vector2 ScrollTargetCenterRatio => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollTargetCenterRatio);
+        public ref Vector2 ScrollTargetEdgeSnapDist => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollTargetEdgeSnapDist);
+        public ref Vector2 ScrollbarSizes => ref Unsafe.AsRef<Vector2>(&NativePtr->ScrollbarSizes);
+        public ref bool ScrollbarX => ref Unsafe.AsRef<bool>(&NativePtr->ScrollbarX);
+        public ref bool ScrollbarY => ref Unsafe.AsRef<bool>(&NativePtr->ScrollbarY);
+        public ref bool ViewportOwned => ref Unsafe.AsRef<bool>(&NativePtr->ViewportOwned);
+        public ref bool Active => ref Unsafe.AsRef<bool>(&NativePtr->Active);
+        public ref bool WasActive => ref Unsafe.AsRef<bool>(&NativePtr->WasActive);
+        public ref bool WriteAccessed => ref Unsafe.AsRef<bool>(&NativePtr->WriteAccessed);
+        public ref bool Collapsed => ref Unsafe.AsRef<bool>(&NativePtr->Collapsed);
+        public ref bool WantCollapseToggle => ref Unsafe.AsRef<bool>(&NativePtr->WantCollapseToggle);
+        public ref bool SkipItems => ref Unsafe.AsRef<bool>(&NativePtr->SkipItems);
+        public ref bool Appearing => ref Unsafe.AsRef<bool>(&NativePtr->Appearing);
+        public ref bool Hidden => ref Unsafe.AsRef<bool>(&NativePtr->Hidden);
+        public ref bool IsFallbackWindow => ref Unsafe.AsRef<bool>(&NativePtr->IsFallbackWindow);
+        public ref bool IsExplicitChild => ref Unsafe.AsRef<bool>(&NativePtr->IsExplicitChild);
+        public ref bool HasCloseButton => ref Unsafe.AsRef<bool>(&NativePtr->HasCloseButton);
+        public ref sbyte ResizeBorderHeld => ref Unsafe.AsRef<sbyte>(&NativePtr->ResizeBorderHeld);
+        public ref short BeginCount => ref Unsafe.AsRef<short>(&NativePtr->BeginCount);
+        public ref short BeginOrderWithinParent => ref Unsafe.AsRef<short>(&NativePtr->BeginOrderWithinParent);
+        public ref short BeginOrderWithinContext => ref Unsafe.AsRef<short>(&NativePtr->BeginOrderWithinContext);
+        public ref short FocusOrder => ref Unsafe.AsRef<short>(&NativePtr->FocusOrder);
+        public ref uint PopupId => ref Unsafe.AsRef<uint>(&NativePtr->PopupId);
+        public ref sbyte AutoFitFramesX => ref Unsafe.AsRef<sbyte>(&NativePtr->AutoFitFramesX);
+        public ref sbyte AutoFitFramesY => ref Unsafe.AsRef<sbyte>(&NativePtr->AutoFitFramesY);
+        public ref sbyte AutoFitChildAxises => ref Unsafe.AsRef<sbyte>(&NativePtr->AutoFitChildAxises);
+        public ref bool AutoFitOnlyGrows => ref Unsafe.AsRef<bool>(&NativePtr->AutoFitOnlyGrows);
+        public ref ImGuiDir AutoPosLastDirection => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->AutoPosLastDirection);
+        public ref sbyte HiddenFramesCanSkipItems => ref Unsafe.AsRef<sbyte>(&NativePtr->HiddenFramesCanSkipItems);
+        public ref sbyte HiddenFramesCannotSkipItems => ref Unsafe.AsRef<sbyte>(&NativePtr->HiddenFramesCannotSkipItems);
+        public ref sbyte HiddenFramesForRenderOnly => ref Unsafe.AsRef<sbyte>(&NativePtr->HiddenFramesForRenderOnly);
+        public ref sbyte DisableInputsFrames => ref Unsafe.AsRef<sbyte>(&NativePtr->DisableInputsFrames);
+        public ref ImGuiCond SetWindowPosAllowFlags => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SetWindowPosAllowFlags);
+        public ref ImGuiCond SetWindowSizeAllowFlags => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SetWindowSizeAllowFlags);
+        public ref ImGuiCond SetWindowCollapsedAllowFlags => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SetWindowCollapsedAllowFlags);
+        public ref ImGuiCond SetWindowDockAllowFlags => ref Unsafe.AsRef<ImGuiCond>(&NativePtr->SetWindowDockAllowFlags);
+        public ref Vector2 SetWindowPosVal => ref Unsafe.AsRef<Vector2>(&NativePtr->SetWindowPosVal);
+        public ref Vector2 SetWindowPosPivot => ref Unsafe.AsRef<Vector2>(&NativePtr->SetWindowPosPivot);
+        public ImVector<uint> IDStack => new ImVector<uint>(NativePtr->IDStack);
+        public ref ImGuiWindowTempData DC => ref Unsafe.AsRef<ImGuiWindowTempData>(&NativePtr->DC);
+        public ref ImRect OuterRectClipped => ref Unsafe.AsRef<ImRect>(&NativePtr->OuterRectClipped);
+        public ref ImRect InnerRect => ref Unsafe.AsRef<ImRect>(&NativePtr->InnerRect);
+        public ref ImRect InnerClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->InnerClipRect);
+        public ref ImRect WorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->WorkRect);
+        public ref ImRect ParentWorkRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ParentWorkRect);
+        public ref ImRect ClipRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ClipRect);
+        public ref ImRect ContentRegionRect => ref Unsafe.AsRef<ImRect>(&NativePtr->ContentRegionRect);
+        public ref ImVec2ih HitTestHoleSize => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->HitTestHoleSize);
+        public ref ImVec2ih HitTestHoleOffset => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->HitTestHoleOffset);
+        public ref int LastFrameActive => ref Unsafe.AsRef<int>(&NativePtr->LastFrameActive);
+        public ref int LastFrameJustFocused => ref Unsafe.AsRef<int>(&NativePtr->LastFrameJustFocused);
+        public ref float LastTimeActive => ref Unsafe.AsRef<float>(&NativePtr->LastTimeActive);
+        public ref float ItemWidthDefault => ref Unsafe.AsRef<float>(&NativePtr->ItemWidthDefault);
+        public ref ImGuiStorage StateStorage => ref Unsafe.AsRef<ImGuiStorage>(&NativePtr->StateStorage);
+        public ImPtrVector<ImGuiOldColumnsPtr> ColumnsStorage => new ImPtrVector<ImGuiOldColumnsPtr>(NativePtr->ColumnsStorage, Unsafe.SizeOf<ImGuiOldColumns>());
+        public ref float FontWindowScale => ref Unsafe.AsRef<float>(&NativePtr->FontWindowScale);
+        public ref float FontDpiScale => ref Unsafe.AsRef<float>(&NativePtr->FontDpiScale);
+        public ref int SettingsOffset => ref Unsafe.AsRef<int>(&NativePtr->SettingsOffset);
+        public ImDrawListPtr DrawList => new ImDrawListPtr(NativePtr->DrawList);
+        public ref ImDrawList DrawListInst => ref Unsafe.AsRef<ImDrawList>(&NativePtr->DrawListInst);
+        public ImGuiWindowPtr ParentWindow => new ImGuiWindowPtr(NativePtr->ParentWindow);
+        public ImGuiWindowPtr ParentWindowInBeginStack => new ImGuiWindowPtr(NativePtr->ParentWindowInBeginStack);
+        public ImGuiWindowPtr RootWindow => new ImGuiWindowPtr(NativePtr->RootWindow);
+        public ImGuiWindowPtr RootWindowPopupTree => new ImGuiWindowPtr(NativePtr->RootWindowPopupTree);
+        public ImGuiWindowPtr RootWindowDockTree => new ImGuiWindowPtr(NativePtr->RootWindowDockTree);
+        public ImGuiWindowPtr RootWindowForTitleBarHighlight => new ImGuiWindowPtr(NativePtr->RootWindowForTitleBarHighlight);
+        public ImGuiWindowPtr RootWindowForNav => new ImGuiWindowPtr(NativePtr->RootWindowForNav);
+        public ImGuiWindowPtr NavLastChildNavWindow => new ImGuiWindowPtr(NativePtr->NavLastChildNavWindow);
+        public RangeAccessor<uint> NavLastIds => new RangeAccessor<uint>(NativePtr->NavLastIds, 2);
+        public RangeAccessor<ImRect> NavRectRel => new RangeAccessor<ImRect>(&NativePtr->NavRectRel_0, 2);
+        public ref int MemoryDrawListIdxCapacity => ref Unsafe.AsRef<int>(&NativePtr->MemoryDrawListIdxCapacity);
+        public ref int MemoryDrawListVtxCapacity => ref Unsafe.AsRef<int>(&NativePtr->MemoryDrawListVtxCapacity);
+        public ref bool MemoryCompacted => ref Unsafe.AsRef<bool>(&NativePtr->MemoryCompacted);
+        public ref bool DockIsActive => ref Unsafe.AsRef<bool>(&NativePtr->DockIsActive);
+        public ref bool DockNodeIsVisible => ref Unsafe.AsRef<bool>(&NativePtr->DockNodeIsVisible);
+        public ref bool DockTabIsVisible => ref Unsafe.AsRef<bool>(&NativePtr->DockTabIsVisible);
+        public ref bool DockTabWantClose => ref Unsafe.AsRef<bool>(&NativePtr->DockTabWantClose);
+        public ref short DockOrder => ref Unsafe.AsRef<short>(&NativePtr->DockOrder);
+        public ref ImGuiWindowDockStyle DockStyle => ref Unsafe.AsRef<ImGuiWindowDockStyle>(&NativePtr->DockStyle);
+        public ImGuiDockNodePtr DockNode => new ImGuiDockNodePtr(NativePtr->DockNode);
+        public ImGuiDockNodePtr DockNodeAsHost => new ImGuiDockNodePtr(NativePtr->DockNodeAsHost);
+        public ref uint DockId => ref Unsafe.AsRef<uint>(&NativePtr->DockId);
+        public ref ImGuiItemStatusFlags DockTabItemStatusFlags => ref Unsafe.AsRef<ImGuiItemStatusFlags>(&NativePtr->DockTabItemStatusFlags);
+        public ref ImRect DockTabItemRect => ref Unsafe.AsRef<ImRect>(&NativePtr->DockTabItemRect);
+        public float CalcFontSize()
+        {
+            float ret = ImGuiNative.ImGuiWindow_CalcFontSize((ImGuiWindow*)(NativePtr));
+            return ret;
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiWindow_destroy((ImGuiWindow*)(NativePtr));
+        }
+        public uint GetID(string str)
+        {
+            byte* native_str;
+            int str_byteCount = 0;
+            if (str != null)
+            {
+                str_byteCount = Encoding.UTF8.GetByteCount(str);
+                if (str_byteCount > Util.StackAllocationSizeLimit)
+                {
+                    native_str = Util.Allocate(str_byteCount + 1);
+                }
+                else
+                {
+                    byte* native_str_stackBytes = stackalloc byte[str_byteCount + 1];
+                    native_str = native_str_stackBytes;
+                }
+                int native_str_offset = Util.GetUtf8(str, native_str, str_byteCount);
+                native_str[native_str_offset] = 0;
+            }
+            else { native_str = null; }
+            byte* native_str_end = null;
+            uint ret = ImGuiNative.ImGuiWindow_GetID_Str((ImGuiWindow*)(NativePtr), native_str, native_str_end);
+            if (str_byteCount > Util.StackAllocationSizeLimit)
+            {
+                Util.Free(native_str);
+            }
+            return ret;
+        }
+        public uint GetID(IntPtr ptr)
+        {
+            void* native_ptr = (void*)ptr.ToPointer();
+            uint ret = ImGuiNative.ImGuiWindow_GetID_Ptr((ImGuiWindow*)(NativePtr), native_ptr);
+            return ret;
+        }
+        public uint GetID(int n)
+        {
+            uint ret = ImGuiNative.ImGuiWindow_GetID_Int((ImGuiWindow*)(NativePtr), n);
+            return ret;
+        }
+        public uint GetIDFromRectangle(ImRect r_abs)
+        {
+            uint ret = ImGuiNative.ImGuiWindow_GetIDFromRectangle((ImGuiWindow*)(NativePtr), r_abs);
+            return ret;
+        }
+        public float MenuBarHeight()
+        {
+            float ret = ImGuiNative.ImGuiWindow_MenuBarHeight((ImGuiWindow*)(NativePtr));
+            return ret;
+        }
+        public ImRect MenuBarRect()
+        {
+            ImRect __retval;
+            ImGuiNative.ImGuiWindow_MenuBarRect(&__retval, (ImGuiWindow*)(NativePtr));
+            return __retval;
+        }
+        public ImRect Rect()
+        {
+            ImRect __retval;
+            ImGuiNative.ImGuiWindow_Rect(&__retval, (ImGuiWindow*)(NativePtr));
+            return __retval;
+        }
+        public float TitleBarHeight()
+        {
+            float ret = ImGuiNative.ImGuiWindow_TitleBarHeight((ImGuiWindow*)(NativePtr));
+            return ret;
+        }
+        public ImRect TitleBarRect()
+        {
+            ImRect __retval;
+            ImGuiNative.ImGuiWindow_TitleBarRect(&__retval, (ImGuiWindow*)(NativePtr));
+            return __retval;
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiWindowDockStyle.gen.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiWindowDockStyle
+    {
+        public fixed uint Colors[6];
+    }
+    public unsafe partial struct ImGuiWindowDockStylePtr
+    {
+        public ImGuiWindowDockStyle* NativePtr { get; }
+        public ImGuiWindowDockStylePtr(ImGuiWindowDockStyle* nativePtr) => NativePtr = nativePtr;
+        public ImGuiWindowDockStylePtr(IntPtr nativePtr) => NativePtr = (ImGuiWindowDockStyle*)nativePtr;
+        public static implicit operator ImGuiWindowDockStylePtr(ImGuiWindowDockStyle* nativePtr) => new ImGuiWindowDockStylePtr(nativePtr);
+        public static implicit operator ImGuiWindowDockStyle* (ImGuiWindowDockStylePtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiWindowDockStylePtr(IntPtr nativePtr) => new ImGuiWindowDockStylePtr(nativePtr);
+        public RangeAccessor<uint> Colors => new RangeAccessor<uint>(NativePtr->Colors, 6);
+    }
+}

src/ImGui.NET/Generated/ImGuiWindowDockStyleCol.gen.cs

@@ -0,0 +1,13 @@
+namespace ImGuiNET
+{
+    public enum ImGuiWindowDockStyleCol
+    {
+        Text = 0,
+        Tab = 1,
+        TabHovered = 2,
+        TabActive = 3,
+        TabUnfocused = 4,
+        TabUnfocusedActive = 5,
+        COUNT = 6,
+    }
+}

src/ImGui.NET/Generated/ImGuiWindowSettings.gen.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiWindowSettings
+    {
+        public uint ID;
+        public ImVec2ih Pos;
+        public ImVec2ih Size;
+        public ImVec2ih ViewportPos;
+        public uint ViewportId;
+        public uint DockId;
+        public uint ClassId;
+        public short DockOrder;
+        public byte Collapsed;
+        public byte WantApply;
+    }
+    public unsafe partial struct ImGuiWindowSettingsPtr
+    {
+        public ImGuiWindowSettings* NativePtr { get; }
+        public ImGuiWindowSettingsPtr(ImGuiWindowSettings* nativePtr) => NativePtr = nativePtr;
+        public ImGuiWindowSettingsPtr(IntPtr nativePtr) => NativePtr = (ImGuiWindowSettings*)nativePtr;
+        public static implicit operator ImGuiWindowSettingsPtr(ImGuiWindowSettings* nativePtr) => new ImGuiWindowSettingsPtr(nativePtr);
+        public static implicit operator ImGuiWindowSettings* (ImGuiWindowSettingsPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiWindowSettingsPtr(IntPtr nativePtr) => new ImGuiWindowSettingsPtr(nativePtr);
+        public ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);
+        public ref ImVec2ih Pos => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->Pos);
+        public ref ImVec2ih Size => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->Size);
+        public ref ImVec2ih ViewportPos => ref Unsafe.AsRef<ImVec2ih>(&NativePtr->ViewportPos);
+        public ref uint ViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ViewportId);
+        public ref uint DockId => ref Unsafe.AsRef<uint>(&NativePtr->DockId);
+        public ref uint ClassId => ref Unsafe.AsRef<uint>(&NativePtr->ClassId);
+        public ref short DockOrder => ref Unsafe.AsRef<short>(&NativePtr->DockOrder);
+        public ref bool Collapsed => ref Unsafe.AsRef<bool>(&NativePtr->Collapsed);
+        public ref bool WantApply => ref Unsafe.AsRef<bool>(&NativePtr->WantApply);
+        public void Destroy()
+        {
+            ImGuiNative.ImGuiWindowSettings_destroy((ImGuiWindowSettings*)(NativePtr));
+        }
+        public string GetName()
+        {
+            byte* ret = ImGuiNative.ImGuiWindowSettings_GetName((ImGuiWindowSettings*)(NativePtr));
+            return Util.StringFromPtr(ret);
+        }
+    }
+}

src/ImGui.NET/Generated/ImGuiWindowStackData.gen.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiWindowStackData
+    {
+        public ImGuiWindow* Window;
+        public ImGuiLastItemData ParentLastItemDataBackup;
+        public ImGuiStackSizes StackSizesOnBegin;
+    }
+    public unsafe partial struct ImGuiWindowStackDataPtr
+    {
+        public ImGuiWindowStackData* NativePtr { get; }
+        public ImGuiWindowStackDataPtr(ImGuiWindowStackData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiWindowStackDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiWindowStackData*)nativePtr;
+        public static implicit operator ImGuiWindowStackDataPtr(ImGuiWindowStackData* nativePtr) => new ImGuiWindowStackDataPtr(nativePtr);
+        public static implicit operator ImGuiWindowStackData* (ImGuiWindowStackDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiWindowStackDataPtr(IntPtr nativePtr) => new ImGuiWindowStackDataPtr(nativePtr);
+        public ImGuiWindowPtr Window => new ImGuiWindowPtr(NativePtr->Window);
+        public ref ImGuiLastItemData ParentLastItemDataBackup => ref Unsafe.AsRef<ImGuiLastItemData>(&NativePtr->ParentLastItemDataBackup);
+        public ref ImGuiStackSizes StackSizesOnBegin => ref Unsafe.AsRef<ImGuiStackSizes>(&NativePtr->StackSizesOnBegin);
+    }
+}

src/ImGui.NET/Generated/ImGuiWindowTempData.gen.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImGuiWindowTempData
+    {
+        public Vector2 CursorPos;
+        public Vector2 CursorPosPrevLine;
+        public Vector2 CursorStartPos;
+        public Vector2 CursorMaxPos;
+        public Vector2 IdealMaxPos;
+        public Vector2 CurrLineSize;
+        public Vector2 PrevLineSize;
+        public float CurrLineTextBaseOffset;
+        public float PrevLineTextBaseOffset;
+        public byte IsSameLine;
+        public ImVec1 Indent;
+        public ImVec1 ColumnsOffset;
+        public ImVec1 GroupOffset;
+        public Vector2 CursorStartPosLossyness;
+        public ImGuiNavLayer NavLayerCurrent;
+        public short NavLayersActiveMask;
+        public short NavLayersActiveMaskNext;
+        public uint NavFocusScopeIdCurrent;
+        public byte NavHideHighlightOneFrame;
+        public byte NavHasScroll;
+        public byte MenuBarAppending;
+        public Vector2 MenuBarOffset;
+        public ImGuiMenuColumns MenuColumns;
+        public int TreeDepth;
+        public uint TreeJumpToParentOnPopMask;
+        public ImVector ChildWindows;
+        public ImGuiStorage* StateStorage;
+        public ImGuiOldColumns* CurrentColumns;
+        public int CurrentTableIdx;
+        public ImGuiLayoutType LayoutType;
+        public ImGuiLayoutType ParentLayoutType;
+        public float ItemWidth;
+        public float TextWrapPos;
+        public ImVector ItemWidthStack;
+        public ImVector TextWrapPosStack;
+    }
+    public unsafe partial struct ImGuiWindowTempDataPtr
+    {
+        public ImGuiWindowTempData* NativePtr { get; }
+        public ImGuiWindowTempDataPtr(ImGuiWindowTempData* nativePtr) => NativePtr = nativePtr;
+        public ImGuiWindowTempDataPtr(IntPtr nativePtr) => NativePtr = (ImGuiWindowTempData*)nativePtr;
+        public static implicit operator ImGuiWindowTempDataPtr(ImGuiWindowTempData* nativePtr) => new ImGuiWindowTempDataPtr(nativePtr);
+        public static implicit operator ImGuiWindowTempData* (ImGuiWindowTempDataPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImGuiWindowTempDataPtr(IntPtr nativePtr) => new ImGuiWindowTempDataPtr(nativePtr);
+        public ref Vector2 CursorPos => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorPos);
+        public ref Vector2 CursorPosPrevLine => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorPosPrevLine);
+        public ref Vector2 CursorStartPos => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorStartPos);
+        public ref Vector2 CursorMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorMaxPos);
+        public ref Vector2 IdealMaxPos => ref Unsafe.AsRef<Vector2>(&NativePtr->IdealMaxPos);
+        public ref Vector2 CurrLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->CurrLineSize);
+        public ref Vector2 PrevLineSize => ref Unsafe.AsRef<Vector2>(&NativePtr->PrevLineSize);
+        public ref float CurrLineTextBaseOffset => ref Unsafe.AsRef<float>(&NativePtr->CurrLineTextBaseOffset);
+        public ref float PrevLineTextBaseOffset => ref Unsafe.AsRef<float>(&NativePtr->PrevLineTextBaseOffset);
+        public ref bool IsSameLine => ref Unsafe.AsRef<bool>(&NativePtr->IsSameLine);
+        public ref ImVec1 Indent => ref Unsafe.AsRef<ImVec1>(&NativePtr->Indent);
+        public ref ImVec1 ColumnsOffset => ref Unsafe.AsRef<ImVec1>(&NativePtr->ColumnsOffset);
+        public ref ImVec1 GroupOffset => ref Unsafe.AsRef<ImVec1>(&NativePtr->GroupOffset);
+        public ref Vector2 CursorStartPosLossyness => ref Unsafe.AsRef<Vector2>(&NativePtr->CursorStartPosLossyness);
+        public ref ImGuiNavLayer NavLayerCurrent => ref Unsafe.AsRef<ImGuiNavLayer>(&NativePtr->NavLayerCurrent);
+        public ref short NavLayersActiveMask => ref Unsafe.AsRef<short>(&NativePtr->NavLayersActiveMask);
+        public ref short NavLayersActiveMaskNext => ref Unsafe.AsRef<short>(&NativePtr->NavLayersActiveMaskNext);
+        public ref uint NavFocusScopeIdCurrent => ref Unsafe.AsRef<uint>(&NativePtr->NavFocusScopeIdCurrent);
+        public ref bool NavHideHighlightOneFrame => ref Unsafe.AsRef<bool>(&NativePtr->NavHideHighlightOneFrame);
+        public ref bool NavHasScroll => ref Unsafe.AsRef<bool>(&NativePtr->NavHasScroll);
+        public ref bool MenuBarAppending => ref Unsafe.AsRef<bool>(&NativePtr->MenuBarAppending);
+        public ref Vector2 MenuBarOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->MenuBarOffset);
+        public ref ImGuiMenuColumns MenuColumns => ref Unsafe.AsRef<ImGuiMenuColumns>(&NativePtr->MenuColumns);
+        public ref int TreeDepth => ref Unsafe.AsRef<int>(&NativePtr->TreeDepth);
+        public ref uint TreeJumpToParentOnPopMask => ref Unsafe.AsRef<uint>(&NativePtr->TreeJumpToParentOnPopMask);
+        public ImVector<ImGuiWindowPtr> ChildWindows => new ImVector<ImGuiWindowPtr>(NativePtr->ChildWindows);
+        public ImGuiStoragePtr StateStorage => new ImGuiStoragePtr(NativePtr->StateStorage);
+        public ImGuiOldColumnsPtr CurrentColumns => new ImGuiOldColumnsPtr(NativePtr->CurrentColumns);
+        public ref int CurrentTableIdx => ref Unsafe.AsRef<int>(&NativePtr->CurrentTableIdx);
+        public ref ImGuiLayoutType LayoutType => ref Unsafe.AsRef<ImGuiLayoutType>(&NativePtr->LayoutType);
+        public ref ImGuiLayoutType ParentLayoutType => ref Unsafe.AsRef<ImGuiLayoutType>(&NativePtr->ParentLayoutType);
+        public ref float ItemWidth => ref Unsafe.AsRef<float>(&NativePtr->ItemWidth);
+        public ref float TextWrapPos => ref Unsafe.AsRef<float>(&NativePtr->TextWrapPos);
+        public ImVector<float> ItemWidthStack => new ImVector<float>(NativePtr->ItemWidthStack);
+        public ImVector<float> TextWrapPosStack => new ImVector<float>(NativePtr->TextWrapPosStack);
+    }
+}

src/ImGui.NET/Generated/ImRect.gen.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImRect
+    {
+        public Vector2 Min;
+        public Vector2 Max;
+    }
+    public unsafe partial struct ImRectPtr
+    {
+        public ImRect* NativePtr { get; }
+        public ImRectPtr(ImRect* nativePtr) => NativePtr = nativePtr;
+        public ImRectPtr(IntPtr nativePtr) => NativePtr = (ImRect*)nativePtr;
+        public static implicit operator ImRectPtr(ImRect* nativePtr) => new ImRectPtr(nativePtr);
+        public static implicit operator ImRect* (ImRectPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImRectPtr(IntPtr nativePtr) => new ImRectPtr(nativePtr);
+        public ref Vector2 Min => ref Unsafe.AsRef<Vector2>(&NativePtr->Min);
+        public ref Vector2 Max => ref Unsafe.AsRef<Vector2>(&NativePtr->Max);
+        public void Add(Vector2 p)
+        {
+            ImGuiNative.ImRect_Add_Vec2((ImRect*)(NativePtr), p);
+        }
+        public void Add(ImRect r)
+        {
+            ImGuiNative.ImRect_Add_Rect((ImRect*)(NativePtr), r);
+        }
+        public void ClipWith(ImRect r)
+        {
+            ImGuiNative.ImRect_ClipWith((ImRect*)(NativePtr), r);
+        }
+        public void ClipWithFull(ImRect r)
+        {
+            ImGuiNative.ImRect_ClipWithFull((ImRect*)(NativePtr), r);
+        }
+        public bool Contains(Vector2 p)
+        {
+            byte ret = ImGuiNative.ImRect_Contains_Vec2((ImRect*)(NativePtr), p);
+            return ret != 0;
+        }
+        public bool Contains(ImRect r)
+        {
+            byte ret = ImGuiNative.ImRect_Contains_Rect((ImRect*)(NativePtr), r);
+            return ret != 0;
+        }
+        public void Destroy()
+        {
+            ImGuiNative.ImRect_destroy((ImRect*)(NativePtr));
+        }
+        public void Expand(float amount)
+        {
+            ImGuiNative.ImRect_Expand_Float((ImRect*)(NativePtr), amount);
+        }
+        public void Expand(Vector2 amount)
+        {
+            ImGuiNative.ImRect_Expand_Vec2((ImRect*)(NativePtr), amount);
+        }
+        public void Floor()
+        {
+            ImGuiNative.ImRect_Floor((ImRect*)(NativePtr));
+        }
+        public float GetArea()
+        {
+            float ret = ImGuiNative.ImRect_GetArea((ImRect*)(NativePtr));
+            return ret;
+        }
+        public Vector2 GetBL()
+        {
+            Vector2 __retval;
+            ImGuiNative.ImRect_GetBL(&__retval, (ImRect*)(NativePtr));
+            return __retval;
+        }
+        public Vector2 GetBR()
+        {
+            Vector2 __retval;
+            ImGuiNative.ImRect_GetBR(&__retval, (ImRect*)(NativePtr));
+            return __retval;
+        }
+        public Vector2 GetCenter()
+        {
+            Vector2 __retval;
+            ImGuiNative.ImRect_GetCenter(&__retval, (ImRect*)(NativePtr));
+            return __retval;
+        }
+        public float GetHeight()
+        {
+            float ret = ImGuiNative.ImRect_GetHeight((ImRect*)(NativePtr));
+            return ret;
+        }
+        public Vector2 GetSize()
+        {
+            Vector2 __retval;
+            ImGuiNative.ImRect_GetSize(&__retval, (ImRect*)(NativePtr));
+            return __retval;
+        }
+        public Vector2 GetTL()
+        {
+            Vector2 __retval;
+            ImGuiNative.ImRect_GetTL(&__retval, (ImRect*)(NativePtr));
+            return __retval;
+        }
+        public Vector2 GetTR()
+        {
+            Vector2 __retval;
+            ImGuiNative.ImRect_GetTR(&__retval, (ImRect*)(NativePtr));
+            return __retval;
+        }
+        public float GetWidth()
+        {
+            float ret = ImGuiNative.ImRect_GetWidth((ImRect*)(NativePtr));
+            return ret;
+        }
+        public bool IsInverted()
+        {
+            byte ret = ImGuiNative.ImRect_IsInverted((ImRect*)(NativePtr));
+            return ret != 0;
+        }
+        public bool Overlaps(ImRect r)
+        {
+            byte ret = ImGuiNative.ImRect_Overlaps((ImRect*)(NativePtr), r);
+            return ret != 0;
+        }
+        public Vector4 ToVec4()
+        {
+            Vector4 __retval;
+            ImGuiNative.ImRect_ToVec4(&__retval, (ImRect*)(NativePtr));
+            return __retval;
+        }
+        public void Translate(Vector2 d)
+        {
+            ImGuiNative.ImRect_Translate((ImRect*)(NativePtr), d);
+        }
+        public void TranslateX(float dx)
+        {
+            ImGuiNative.ImRect_TranslateX((ImRect*)(NativePtr), dx);
+        }
+        public void TranslateY(float dy)
+        {
+            ImGuiNative.ImRect_TranslateY((ImRect*)(NativePtr), dy);
+        }
+    }
+}

src/ImGui.NET/Generated/ImVec1.gen.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImVec1
+    {
+        public float x;
+    }
+    public unsafe partial struct ImVec1Ptr
+    {
+        public ImVec1* NativePtr { get; }
+        public ImVec1Ptr(ImVec1* nativePtr) => NativePtr = nativePtr;
+        public ImVec1Ptr(IntPtr nativePtr) => NativePtr = (ImVec1*)nativePtr;
+        public static implicit operator ImVec1Ptr(ImVec1* nativePtr) => new ImVec1Ptr(nativePtr);
+        public static implicit operator ImVec1* (ImVec1Ptr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImVec1Ptr(IntPtr nativePtr) => new ImVec1Ptr(nativePtr);
+        public ref float x => ref Unsafe.AsRef<float>(&NativePtr->x);
+        public void Destroy()
+        {
+            ImGuiNative.ImVec1_destroy((ImVec1*)(NativePtr));
+        }
+    }
+}

src/ImGui.NET/Generated/ImVec2ih.gen.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace ImGuiNET.Internal
+{
+    public unsafe partial struct ImVec2ih
+    {
+        public short x;
+        public short y;
+    }
+    public unsafe partial struct ImVec2ihPtr
+    {
+        public ImVec2ih* NativePtr { get; }
+        public ImVec2ihPtr(ImVec2ih* nativePtr) => NativePtr = nativePtr;
+        public ImVec2ihPtr(IntPtr nativePtr) => NativePtr = (ImVec2ih*)nativePtr;
+        public static implicit operator ImVec2ihPtr(ImVec2ih* nativePtr) => new ImVec2ihPtr(nativePtr);
+        public static implicit operator ImVec2ih* (ImVec2ihPtr wrappedPtr) => wrappedPtr.NativePtr;
+        public static implicit operator ImVec2ihPtr(IntPtr nativePtr) => new ImVec2ihPtr(nativePtr);
+        public ref short x => ref Unsafe.AsRef<short>(&NativePtr->x);
+        public ref short y => ref Unsafe.AsRef<short>(&NativePtr->y);
+        public void Destroy()
+        {
+            ImGuiNative.ImVec2ih_destroy((ImVec2ih*)(NativePtr));
+        }
+    }
+}