imgui

    Dark Mode
Search:
Group by:

ImGUI Bindings

WARNING: This is a generated file. Do not edit Any edits will be overwritten by the genearator.

The aim is to achieve as much compatibility with C as possible. Optional helper functions have been created as a submodule imgui/imgui_helpers to better bind this library to Nim.

You can check the original documentation here.

Source language of ImGui is C++, since Nim is able to compile both to C and C++ you can select which compile target you wish to use. Note that to use the C backend you must supply a cimgui dynamic library file.

HACK: If you are targeting Windows, be sure to compile the cimgui dll with visual studio and not with mingw.

Types

ImDrawCornerFlags {...}{.pure, size: 4.} = enum
  None = 0, TopLeft = 1, TopRight = 2, Top = 3, BotLeft = 4, Left = 5,
  BotRight = 8, Right = 10, Bot = 12, All = 15
ImDrawListFlags {...}{.pure, size: 4.} = enum
  None = 0, AntiAliasedLines = 1, AntiAliasedLinesUseTex = 2,
  AntiAliasedFill = 4, AllowVtxOffset = 8
ImFontAtlasFlags {...}{.pure, size: 4.} = enum
  None = 0, NoPowerOfTwoHeight = 1, NoMouseCursors = 2, NoBakedLines = 4
ImGuiAxis {...}{.pure, size: 4.} = enum
  None = -1, X = 0, Y = 1
ImGuiBackendFlags {...}{.pure, size: 4.} = enum
  None = 0, HasGamepad = 1, HasMouseCursors = 2, HasSetMousePos = 4,
  RendererHasVtxOffset = 8
ImGuiButtonFlagsPrivate {...}{.pure, size: 4.} = enum
  PressedOnClick = 16, PressedOnClickRelease = 32,
  PressedOnClickReleaseAnywhere = 64, PressedOnRelease = 128,
  PressedOnDoubleClick = 256, PressedOnDragDropHold = 512, PressedOnMask = 1008,
  Repeat = 1024, FlattenChildren = 2048, AllowItemOverlap = 4096,
  DontClosePopups = 8192, Disabled = 16384, AlignTextBaseLine = 32768,
  NoKeyModifiers = 65536, NoHoldingActiveId = 131072, NoNavFocus = 262144,
  NoHoveredOnFocus = 524288
ImGuiButtonFlags {...}{.pure, size: 4.} = enum
  None = 0, MouseButtonLeft = 1, MouseButtonRight = 2, MouseButtonMiddle = 4,
  MouseButtonMask = 7
ImGuiCol {...}{.pure, size: 4.} = enum
  Text = 0, TextDisabled = 1, WindowBg = 2, ChildBg = 3, PopupBg = 4,
  Border = 5, BorderShadow = 6, FrameBg = 7, FrameBgHovered = 8,
  FrameBgActive = 9, TitleBg = 10, TitleBgActive = 11, TitleBgCollapsed = 12,
  MenuBarBg = 13, ScrollbarBg = 14, ScrollbarGrab = 15,
  ScrollbarGrabHovered = 16, ScrollbarGrabActive = 17, CheckMark = 18,
  SliderGrab = 19, SliderGrabActive = 20, Button = 21, ButtonHovered = 22,
  ButtonActive = 23, Header = 24, HeaderHovered = 25, HeaderActive = 26,
  Separator = 27, SeparatorHovered = 28, SeparatorActive = 29, ResizeGrip = 30,
  ResizeGripHovered = 31, ResizeGripActive = 32, Tab = 33, TabHovered = 34,
  TabActive = 35, TabUnfocused = 36, TabUnfocusedActive = 37, PlotLines = 38,
  PlotLinesHovered = 39, PlotHistogram = 40, PlotHistogramHovered = 41,
  TableHeaderBg = 42, TableBorderStrong = 43, TableBorderLight = 44,
  TableRowBg = 45, TableRowBgAlt = 46, TextSelectedBg = 47, DragDropTarget = 48,
  NavHighlight = 49, NavWindowingHighlight = 50, NavWindowingDimBg = 51,
  ModalWindowDimBg = 52
ImGuiColorEditFlags {...}{.pure, size: 4.} = enum
  None = 0, NoAlpha = 2, NoPicker = 4, NoOptions = 8, NoSmallPreview = 16,
  NoInputs = 32, NoTooltip = 64, NoLabel = 128, NoSidePreview = 256,
  NoDragDrop = 512, NoBorder = 1024, AlphaBar = 65536, AlphaPreview = 131072,
  AlphaPreviewHalf = 262144, HDR = 524288, DisplayRGB = 1048576,
  DisplayHSV = 2097152, DisplayHex = 4194304, DisplayMask = 7340032,
  Uint8 = 8388608, Float = 16777216, DataTypeMask = 25165824,
  PickerHueBar = 33554432, PickerHueWheel = 67108864, PickerMask = 100663296,
  InputRGB = 134217728, OptionsDefault = 177209344, InputHSV = 268435456,
  InputMask = 402653184
ImGuiComboFlags {...}{.pure, size: 4.} = enum
  None = 0, PopupAlignLeft = 1, HeightSmall = 2, HeightRegular = 4,
  HeightLarge = 8, HeightLargest = 16, HeightMask = 30, NoArrowButton = 32,
  NoPreview = 64
ImGuiCond {...}{.pure, size: 4.} = enum
  None = 0, Always = 1, Once = 2, FirstUseEver = 4, Appearing = 8
ImGuiConfigFlags {...}{.pure, size: 4.} = enum
  None = 0, NavEnableKeyboard = 1, NavEnableGamepad = 2,
  NavEnableSetMousePos = 4, NavNoCaptureKeyboard = 8, NoMouse = 16,
  NoMouseCursorChange = 32, IsSRGB = 1048576, IsTouchScreen = 2097152
ImGuiContextHookType {...}{.pure, size: 4.} = enum
  NewFramePre = 0, NewFramePost = 1, EndFramePre = 2, EndFramePost = 3,
  RenderPre = 4, RenderPost = 5, Shutdown = 6, PendingRemoval = 7
ImGuiDataTypePrivate {...}{.pure, size: 4.} = enum
  String = 11, Pointer = 12, ID = 13
ImGuiDataType {...}{.pure, size: 4.} = enum
  S8 = 0, U8 = 1, S16 = 2, U16 = 3, S32 = 4, U32 = 5, S64 = 6, U64 = 7,
  Float = 8, Double = 9
ImGuiDir {...}{.pure, size: 4.} = enum
  None = -1, Left = 0, Right = 1, Up = 2, Down = 3
ImGuiDragDropFlags {...}{.pure, size: 4.} = enum
  None = 0, SourceNoPreviewTooltip = 1, SourceNoDisableHover = 2,
  SourceNoHoldToOpenOthers = 4, SourceAllowNullID = 8, SourceExtern = 16,
  SourceAutoExpirePayload = 32, AcceptBeforeDelivery = 1024,
  AcceptNoDrawDefaultRect = 2048, AcceptPeekOnly = 3072,
  AcceptNoPreviewTooltip = 4096
ImGuiFocusedFlags {...}{.pure, size: 4.} = enum
  None = 0, ChildWindows = 1, RootWindow = 2, RootAndChildWindows = 3,
  AnyWindow = 4
ImGuiHoveredFlags {...}{.pure, size: 4.} = enum
  None = 0, ChildWindows = 1, RootWindow = 2, RootAndChildWindows = 3,
  AnyWindow = 4, AllowWhenBlockedByPopup = 8, AllowWhenBlockedByActiveItem = 32,
  AllowWhenOverlapped = 64, RectOnly = 104, AllowWhenDisabled = 128
ImGuiInputReadMode {...}{.pure, size: 4.} = enum
  Down = 0, Pressed = 1, Released = 2, Repeat = 3, RepeatSlow = 4,
  RepeatFast = 5
ImGuiInputSource {...}{.pure, size: 4.} = enum
  None = 0, Mouse = 1, Nav = 2, NavKeyboard = 3, NavGamepad = 4
ImGuiInputTextFlags {...}{.pure, size: 4.} = enum
  None = 0, CharsDecimal = 1, CharsHexadecimal = 2, CharsUppercase = 4,
  CharsNoBlank = 8, AutoSelectAll = 16, EnterReturnsTrue = 32,
  CallbackCompletion = 64, CallbackHistory = 128, CallbackAlways = 256,
  CallbackCharFilter = 512, AllowTabInput = 1024, CtrlEnterForNewLine = 2048,
  NoHorizontalScroll = 4096, AlwaysInsertMode = 8192, ReadOnly = 16384,
  Password = 32768, NoUndoRedo = 65536, CharsScientific = 131072,
  CallbackResize = 262144, CallbackEdit = 524288, Multiline = 1048576,
  NoMarkEdited = 2097152
ImGuiItemFlags {...}{.pure, size: 4.} = enum
  None = 0, NoTabStop = 1, ButtonRepeat = 2, Disabled = 4, NoNav = 8,
  NoNavDefaultFocus = 16, SelectableDontClosePopup = 32, MixedValue = 64,
  ReadOnly = 128
ImGuiItemStatusFlags {...}{.pure, size: 4.} = enum
  None = 0, HoveredRect = 1, HasDisplayRect = 2, Edited = 4,
  ToggledSelection = 8, ToggledOpen = 16, HasDeactivated = 32, Deactivated = 64
ImGuiKeyModFlags {...}{.pure, size: 4.} = enum
  None = 0, Ctrl = 1, Shift = 2, Alt = 4, Super = 8
ImGuiKey {...}{.pure, size: 4.} = enum
  Tab = 0, LeftArrow = 1, RightArrow = 2, UpArrow = 3, DownArrow = 4,
  PageUp = 5, PageDown = 6, Home = 7, End = 8, Insert = 9, Delete = 10,
  Backspace = 11, Space = 12, Enter = 13, Escape = 14, KeyPadEnter = 15, A = 16,
  C = 17, V = 18, X = 19, Y = 20, Z = 21
ImGuiLayoutType {...}{.pure, size: 4.} = enum
  Horizontal = 0, Vertical = 1
ImGuiLogType {...}{.pure, size: 4.} = enum
  None = 0, TTY = 1, File = 2, Buffer = 3, Clipboard = 4
ImGuiMouseButton {...}{.pure, size: 4.} = enum
  Left = 0, Right = 1, Middle = 2
ImGuiMouseCursor {...}{.pure, size: 4.} = enum
  None = -1, Arrow = 0, TextInput = 1, ResizeAll = 2, ResizeNS = 3,
  ResizeEW = 4, ResizeNESW = 5, ResizeNWSE = 6, Hand = 7, NotAllowed = 8
ImGuiNavDirSourceFlags {...}{.pure, size: 4.} = enum
  None = 0, Keyboard = 1, PadDPad = 2, PadLStick = 4
ImGuiNavForward {...}{.pure, size: 4.} = enum
  None = 0, ForwardQueued = 1, ForwardActive = 2
ImGuiNavHighlightFlags {...}{.pure, size: 4.} = enum
  None = 0, TypeDefault = 1, TypeThin = 2, AlwaysDraw = 4, NoRounding = 8
ImGuiNavInput {...}{.pure, size: 4.} = enum
  Activate = 0, Cancel = 1, Input = 2, Menu = 3, DpadLeft = 4, DpadRight = 5,
  DpadUp = 6, DpadDown = 7, LStickLeft = 8, LStickRight = 9, LStickUp = 10,
  LStickDown = 11, FocusPrev = 12, FocusNext = 13, TweakSlow = 14,
  TweakFast = 15, KeyMenu = 16, KeyLeft = 17, KeyRight = 18, KeyUp = 19,
  KeyDown = 20
ImGuiNavLayer {...}{.pure, size: 4.} = enum
  Main = 0, Menu = 1
ImGuiNavMoveFlags {...}{.pure, size: 4.} = enum
  None = 0, LoopX = 1, LoopY = 2, WrapX = 4, WrapY = 8, AllowCurrentNavId = 16,
  AlsoScoreVisibleSet = 32, ScrollToEdge = 64
ImGuiNextItemDataFlags {...}{.pure, size: 4.} = enum
  None = 0, HasWidth = 1, HasOpen = 2
ImGuiNextWindowDataFlags {...}{.pure, size: 4.} = enum
  None = 0, HasPos = 1, HasSize = 2, HasContentSize = 4, HasCollapsed = 8,
  HasSizeConstraint = 16, HasFocus = 32, HasBgAlpha = 64, HasScroll = 128
ImGuiOldColumnFlags {...}{.pure, size: 4.} = enum
  None = 0, NoBorder = 1, NoResize = 2, NoPreserveWidths = 4,
  NoForceWithinWindow = 8, GrowParentContentsSize = 16
ImGuiPlotType {...}{.pure, size: 4.} = enum
  Lines = 0, Histogram = 1
ImGuiPopupFlags {...}{.pure, size: 4.} = enum
  None = 0, MouseButtonRight = 1, MouseButtonMiddle = 2, MouseButtonMask = 31,
  NoOpenOverExistingPopup = 32, NoOpenOverItems = 64, AnyPopupId = 128,
  AnyPopupLevel = 256, AnyPopup = 384
ImGuiPopupPositionPolicy {...}{.pure, size: 4.} = enum
  Default = 0, ComboBox = 1, Tooltip = 2
ImGuiSelectableFlagsPrivate {...}{.pure, size: 4.} = enum
  NoHoldingActiveID = 1048576, SelectOnClick = 2097152,
  SelectOnRelease = 4194304, SpanAvailWidth = 8388608,
  DrawHoveredWhenHeld = 16777216, SetNavIdOnHover = 33554432,
  NoPadWithHalfSpacing = 67108864
ImGuiSelectableFlags {...}{.pure, size: 4.} = enum
  None = 0, DontClosePopups = 1, SpanAllColumns = 2, AllowDoubleClick = 4,
  Disabled = 8, AllowItemOverlap = 16
ImGuiSeparatorFlags {...}{.pure, size: 4.} = enum
  None = 0, Horizontal = 1, Vertical = 2, SpanAllColumns = 4
ImGuiSliderFlagsPrivate {...}{.pure, size: 4.} = enum
  Vertical = 1048576, ReadOnly = 2097152
ImGuiSliderFlags {...}{.pure, size: 4.} = enum
  None = 0, AlwaysClamp = 16, Logarithmic = 32, NoRoundToFormat = 64,
  NoInput = 128, InvalidMask = 1879048207
ImGuiSortDirection {...}{.pure, size: 4.} = enum
  None = 0, Ascending = 1, Descending = 2
ImGuiStyleVar {...}{.pure, size: 4.} = enum
  Alpha = 0, WindowPadding = 1, WindowRounding = 2, WindowBorderSize = 3,
  WindowMinSize = 4, WindowTitleAlign = 5, ChildRounding = 6,
  ChildBorderSize = 7, PopupRounding = 8, PopupBorderSize = 9,
  FramePadding = 10, FrameRounding = 11, FrameBorderSize = 12, ItemSpacing = 13,
  ItemInnerSpacing = 14, IndentSpacing = 15, CellPadding = 16,
  ScrollbarSize = 17, ScrollbarRounding = 18, GrabMinSize = 19,
  GrabRounding = 20, TabRounding = 21, ButtonTextAlign = 22,
  SelectableTextAlign = 23
ImGuiTabBarFlagsPrivate {...}{.pure, size: 4.} = enum
  DockNode = 1048576, IsFocused = 2097152, SaveSettings = 4194304
ImGuiTabBarFlags {...}{.pure, size: 4.} = enum
  None = 0, Reorderable = 1, AutoSelectNewTabs = 2, TabListPopupButton = 4,
  NoCloseWithMiddleMouseButton = 8, NoTabListScrollingButtons = 16,
  NoTooltip = 32, FittingPolicyResizeDown = 64, FittingPolicyScroll = 128,
  FittingPolicyMask = 192
ImGuiTabItemFlagsPrivate {...}{.pure, size: 4.} = enum
  NoCloseButton = 1048576, Button = 2097152
ImGuiTabItemFlags {...}{.pure, size: 4.} = enum
  None = 0, UnsavedDocument = 1, SetSelected = 2,
  NoCloseWithMiddleMouseButton = 4, NoPushId = 8, NoTooltip = 16,
  NoReorder = 32, Leading = 64, Trailing = 128
ImGuiTableBgTarget {...}{.pure, size: 4.} = enum
  None = 0, RowBg0 = 1, RowBg1 = 2, CellBg = 3
ImGuiTableColumnFlags {...}{.pure, size: 4.} = enum
  None = 0, DefaultHide = 1, DefaultSort = 2, WidthStretch = 4, WidthFixed = 8,
  WidthMask = 12, NoResize = 16, NoReorder = 32, NoHide = 64, NoClip = 128,
  NoSort = 256, NoSortAscending = 512, NoSortDescending = 1024,
  NoHeaderWidth = 2048, PreferSortAscending = 4096, PreferSortDescending = 8192,
  IndentEnable = 16384, IndentDisable = 32768, IndentMask = 49152,
  IsEnabled = 1048576, IsVisible = 2097152, IsSorted = 4194304,
  IsHovered = 8388608, StatusMask = 15728640, NoDirectResize = 1073741824
ImGuiTableFlags {...}{.pure, size: 4.} = enum
  None = 0, Resizable = 1, Reorderable = 2, Hideable = 4, Sortable = 8,
  NoSavedSettings = 16, ContextMenuInBody = 32, RowBg = 64, BordersInnerH = 128,
  BordersOuterH = 256, BordersH = 384, BordersInnerV = 512, BordersInner = 640,
  BordersOuterV = 1024, BordersOuter = 1280, BordersV = 1536, Borders = 1920,
  NoBordersInBody = 2048, NoBordersInBodyUntilResize = 4096,
  SizingFixedFit = 8192, SizingFixedSame = 16384, SizingStretchProp = 24576,
  SizingStretchSame = 32768, SizingMask = 57344, NoHostExtendX = 65536,
  NoHostExtendY = 131072, NoKeepColumnsVisible = 262144, PreciseWidths = 524288,
  NoClip = 1048576, PadOuterX = 2097152, NoPadOuterX = 4194304,
  NoPadInnerX = 8388608, ScrollX = 16777216, ScrollY = 33554432,
  SortMulti = 67108864, SortTristate = 134217728
ImGuiTableRowFlags {...}{.pure, size: 4.} = enum
  None = 0, Headers = 1
ImGuiTextFlags {...}{.pure, size: 4.} = enum
  None = 0, NoWidthForLargeClippedText = 1
ImGuiTooltipFlags {...}{.pure, size: 4.} = enum
  None = 0, OverridePreviousTooltip = 1
ImGuiTreeNodeFlagsPrivate {...}{.pure, size: 4.} = enum
  ClipLabelForTrailingButton = 1048576
ImGuiTreeNodeFlags {...}{.pure, size: 4.} = enum
  None = 0, Selected = 1, Framed = 2, AllowItemOverlap = 4,
  NoTreePushOnOpen = 8, NoAutoOpenOnLog = 16, CollapsingHeader = 26,
  DefaultOpen = 32, OpenOnDoubleClick = 64, OpenOnArrow = 128, Leaf = 256,
  Bullet = 512, FramePadding = 1024, SpanAvailWidth = 2048,
  SpanFullWidth = 4096, NavLeftJumpsBackHere = 8192
ImGuiViewportFlags {...}{.pure, size: 4.} = enum
  None = 0, IsPlatformWindow = 1, IsPlatformMonitor = 2, OwnedByApp = 4
ImGuiWindowFlags {...}{.pure, size: 4.} = enum
  None = 0, NoTitleBar = 1, NoResize = 2, NoMove = 4, NoScrollbar = 8,
  NoScrollWithMouse = 16, NoCollapse = 32, NoDecoration = 43,
  AlwaysAutoResize = 64, NoBackground = 128, NoSavedSettings = 256,
  NoMouseInputs = 512, MenuBar = 1024, HorizontalScrollbar = 2048,
  NoFocusOnAppearing = 4096, NoBringToFrontOnFocus = 8192,
  AlwaysVerticalScrollbar = 16384, AlwaysHorizontalScrollbar = 32768,
  AlwaysUseWindowPadding = 65536, NoNavInputs = 262144, NoNavFocus = 524288,
  NoNav = 786432, NoInputs = 786944, UnsavedDocument = 1048576,
  NavFlattened = 8388608, ChildWindow = 16777216, Tooltip = 33554432,
  Popup = 67108864, Modal = 134217728, ChildMenu = 268435456
ImDrawCallback = proc (parent_list: ptr ImDrawList; cmd: ptr ImDrawCmd): void {...}{.
    cdecl, varargs.}
ImDrawIdx = uint16
ImFileHandle = ptr File
ImGuiContextHookCallback = proc (ctx: ptr ImGuiContext;
                                 hook: ptr ImGuiContextHook): void {...}{.cdecl,
    varargs.}
ImGuiErrorLogCallback = proc (user_data: pointer; fmt: cstring): void {...}{.cdecl.}
ImGuiID = uint32
ImGuiInputTextCallback = proc (data: ptr ImGuiInputTextCallbackData): int32 {...}{.
    cdecl, varargs.}
ImGuiSizeCallback = proc (data: ptr ImGuiSizeCallbackData): void {...}{.cdecl,
    varargs.}
ImGuiTableColumnIdx = int8
ImGuiTableDrawChannelIdx = uint8
ImPoolIdx = int32
ImTextureID = pointer
ImWchar = ImWchar16
ImWchar16 = uint16
ImWchar32 = uint32
ImVector[T] = object
  size* {...}{.importc: "Size".}: int32
  capacity* {...}{.importc: "Capacity".}: int32
  data* {...}{.importc: "Data".}: UncheckedArray[T]
ImGuiStyleModBackup {...}{.union.} = object
  backup_int* {...}{.importc: "BackupInt".}: int32
  backup_float* {...}{.importc: "BackupFloat".}: float32
ImGuiStyleMod {...}{.importc: "ImGuiStyleMod", header: "cimgui.h".} = object
  varIdx* {...}{.importc: "VarIdx".}: ImGuiStyleVar
  backup*: ImGuiStyleModBackup
ImGuiStoragePairData {...}{.union.} = object
  val_i* {...}{.importc: "val_i".}: int32
  val_f* {...}{.importc: "val_f".}: float32
  val_p* {...}{.importc: "val_p".}: pointer
ImGuiStoragePair {...}{.importc: "ImGuiStoragePair", header: "cimgui.h".} = object
  key* {...}{.importc: "key".}: ImGuiID
  data*: ImGuiStoragePairData
ImPairData {...}{.union.} = object
  val_i* {...}{.importc: "val_i".}: int32
  val_f* {...}{.importc: "val_f".}: float32
  val_p* {...}{.importc: "val_p".}: pointer
ImPair {...}{.importc: "Pair", header: "cimgui.h".} = object
  key* {...}{.importc: "key".}: ImGuiID
  data*: ImPairData
ImDrawListPtr = object
ImChunkStream = ptr object
ImPool = object
ImSpanAllocator = object
ImSpan = object
ImVectorImGuiColumns {...}{.importc: "ImVector_ImGuiColumns".} = object
ImBitVector {...}{.importc: "ImBitVector", header: "cimgui.h".} = object
  storage* {...}{.importc: "Storage".}: ImVector[uint32]
ImColor {...}{.importc: "ImColor", header: "cimgui.h".} = object
  value* {...}{.importc: "Value".}: ImVec4
ImDrawChannel {...}{.importc: "ImDrawChannel", header: "cimgui.h".} = ptr object
ImDrawCmd {...}{.importc: "ImDrawCmd", header: "cimgui.h".} = object
  clipRect* {...}{.importc: "ClipRect".}: ImVec4
  textureId* {...}{.importc: "TextureId".}: ImTextureID
  vtxOffset* {...}{.importc: "VtxOffset".}: uint32
  idxOffset* {...}{.importc: "IdxOffset".}: uint32
  elemCount* {...}{.importc: "ElemCount".}: uint32
  userCallback* {...}{.importc: "UserCallback".}: ImDrawCallback
  userCallbackData* {...}{.importc: "UserCallbackData".}: pointer
ImDrawCmdHeader {...}{.importc: "ImDrawCmdHeader", header: "cimgui.h".} = object
  clipRect* {...}{.importc: "ClipRect".}: ImVec4
  textureId* {...}{.importc: "TextureId".}: ImTextureID
  vtxOffset* {...}{.importc: "VtxOffset".}: uint32
ImDrawData {...}{.importc: "ImDrawData", header: "cimgui.h".} = object
  valid* {...}{.importc: "Valid".}: bool
  cmdListsCount* {...}{.importc: "CmdListsCount".}: int32
  totalIdxCount* {...}{.importc: "TotalIdxCount".}: int32
  totalVtxCount* {...}{.importc: "TotalVtxCount".}: int32
  cmdLists* {...}{.importc: "CmdLists".}: UncheckedArray[ptr ImDrawList]
  displayPos* {...}{.importc: "DisplayPos".}: ImVec2
  displaySize* {...}{.importc: "DisplaySize".}: ImVec2
  framebufferScale* {...}{.importc: "FramebufferScale".}: ImVec2
ImDrawDataBuilder {...}{.importc: "ImDrawDataBuilder", header: "cimgui.h".} = object
  layers* {...}{.importc: "Layers".}: array[2, ImVector[ImDrawListPtr]]
ImDrawList {...}{.importc: "ImDrawList", header: "cimgui.h".} = object
  cmdBuffer* {...}{.importc: "CmdBuffer".}: ImVector[ImDrawCmd]
  idxBuffer* {...}{.importc: "IdxBuffer".}: ImVector[ImDrawIdx]
  vtxBuffer* {...}{.importc: "VtxBuffer".}: ImVector[ImDrawVert]
  flags* {...}{.importc: "Flags".}: ImDrawListFlags
  vtxCurrentIdx* {...}{.importc: "_VtxCurrentIdx".}: uint32
  data* {...}{.importc: "_Data".}: ptr ImDrawListSharedData
  ownerName* {...}{.importc: "_OwnerName".}: cstring
  vtxWritePtr* {...}{.importc: "_VtxWritePtr".}: ptr ImDrawVert
  idxWritePtr* {...}{.importc: "_IdxWritePtr".}: ptr ImDrawIdx
  clipRectStack* {...}{.importc: "_ClipRectStack".}: ImVector[ImVec4]
  textureIdStack* {...}{.importc: "_TextureIdStack".}: ImVector[ImTextureID]
  path* {...}{.importc: "_Path".}: ImVector[ImVec2]
  cmdHeader* {...}{.importc: "_CmdHeader".}: ImDrawCmdHeader
  splitter* {...}{.importc: "_Splitter".}: ImDrawListSplitter
  fringeScale* {...}{.importc: "_FringeScale".}: float32
ImDrawListSharedData {...}{.importc: "ImDrawListSharedData", header: "cimgui.h".} = object
  texUvWhitePixel* {...}{.importc: "TexUvWhitePixel".}: ImVec2
  font* {...}{.importc: "Font".}: ptr ImFont
  fontSize* {...}{.importc: "FontSize".}: float32
  curveTessellationTol* {...}{.importc: "CurveTessellationTol".}: float32
  circleSegmentMaxError* {...}{.importc: "CircleSegmentMaxError".}: float32
  clipRectFullscreen* {...}{.importc: "ClipRectFullscreen".}: ImVec4
  initialFlags* {...}{.importc: "InitialFlags".}: ImDrawListFlags
  arcFastVtx* {...}{.importc: "ArcFastVtx".}: array[12 * 1, ImVec2]
  circleSegmentCounts* {...}{.importc: "CircleSegmentCounts".}: array[64, uint8]
  texUvLines* {...}{.importc: "TexUvLines".}: ptr ImVec4
ImDrawListSplitter {...}{.importc: "ImDrawListSplitter", header: "cimgui.h".} = object
  current* {...}{.importc: "_Current".}: int32
  count* {...}{.importc: "_Count".}: int32
  channels* {...}{.importc: "_Channels".}: ImVector[ImDrawChannel]
ImDrawVert {...}{.importc: "ImDrawVert", header: "cimgui.h".} = object
  pos* {...}{.importc: "pos".}: ImVec2
  uv* {...}{.importc: "uv".}: ImVec2
  col* {...}{.importc: "col".}: uint32
ImFont {...}{.importc: "ImFont", header: "cimgui.h".} = object
  indexAdvanceX* {...}{.importc: "IndexAdvanceX".}: ImVector[float32]
  fallbackAdvanceX* {...}{.importc: "FallbackAdvanceX".}: float32
  fontSize* {...}{.importc: "FontSize".}: float32
  indexLookup* {...}{.importc: "IndexLookup".}: ImVector[ImWchar]
  glyphs* {...}{.importc: "Glyphs".}: ImVector[ImFontGlyph]
  fallbackGlyph* {...}{.importc: "FallbackGlyph".}: ptr ImFontGlyph
  containerAtlas* {...}{.importc: "ContainerAtlas".}: ptr ImFontAtlas
  configData* {...}{.importc: "ConfigData".}: ptr ImFontConfig
  configDataCount* {...}{.importc: "ConfigDataCount".}: int16
  fallbackChar* {...}{.importc: "FallbackChar".}: ImWchar
  ellipsisChar* {...}{.importc: "EllipsisChar".}: ImWchar
  dirtyLookupTables* {...}{.importc: "DirtyLookupTables".}: bool
  scale* {...}{.importc: "Scale".}: float32
  ascent* {...}{.importc: "Ascent".}: float32
  descent* {...}{.importc: "Descent".}: float32
  metricsTotalSurface* {...}{.importc: "MetricsTotalSurface".}: int32
  used4kPagesMap* {...}{.importc: "Used4kPagesMap".}: array[2, uint8]
ImFontAtlas {...}{.importc: "ImFontAtlas", header: "cimgui.h".} = object
  locked* {...}{.importc: "Locked".}: bool
  flags* {...}{.importc: "Flags".}: ImFontAtlasFlags
  texID* {...}{.importc: "TexID".}: ImTextureID
  texDesiredWidth* {...}{.importc: "TexDesiredWidth".}: int32
  texGlyphPadding* {...}{.importc: "TexGlyphPadding".}: int32
  texPixelsAlpha8* {...}{.importc: "TexPixelsAlpha8".}: ptr cuchar
  texPixelsRGBA32* {...}{.importc: "TexPixelsRGBA32".}: ptr uint32
  texWidth* {...}{.importc: "TexWidth".}: int32
  texHeight* {...}{.importc: "TexHeight".}: int32
  texUvScale* {...}{.importc: "TexUvScale".}: ImVec2
  texUvWhitePixel* {...}{.importc: "TexUvWhitePixel".}: ImVec2
  fonts* {...}{.importc: "Fonts".}: ImVector[ptr ImFont]
  customRects* {...}{.importc: "CustomRects".}: ImVector[ImFontAtlasCustomRect]
  configData* {...}{.importc: "ConfigData".}: ImVector[ImFontConfig]
  texUvLines* {...}{.importc: "TexUvLines".}: array[63 + 1, ImVec4]
  fontBuilderIO* {...}{.importc: "FontBuilderIO".}: ptr ImFontBuilderIO
  fontBuilderFlags* {...}{.importc: "FontBuilderFlags".}: uint32
  packIdMouseCursors* {...}{.importc: "PackIdMouseCursors".}: int32
  packIdLines* {...}{.importc: "PackIdLines".}: int32
ImFontAtlasCustomRect {...}{.importc: "ImFontAtlasCustomRect", header: "cimgui.h".} = object
  width* {...}{.importc: "Width".}: uint16
  height* {...}{.importc: "Height".}: uint16
  x* {...}{.importc: "X".}: uint16
  y* {...}{.importc: "Y".}: uint16
  glyphID* {...}{.importc: "GlyphID".}: uint32
  glyphAdvanceX* {...}{.importc: "GlyphAdvanceX".}: float32
  glyphOffset* {...}{.importc: "GlyphOffset".}: ImVec2
  font* {...}{.importc: "Font".}: ptr ImFont
ImFontBuilderIO {...}{.importc: "ImFontBuilderIO", header: "cimgui.h".} = object
  fontBuilder_Build* {...}{.importc: "FontBuilder_Build".}: proc (
      atlas: ptr ImFontAtlas): bool {...}{.cdecl, varargs.}
ImFontConfig {...}{.importc: "ImFontConfig", header: "cimgui.h".} = object
  fontData* {...}{.importc: "FontData".}: pointer
  fontDataSize* {...}{.importc: "FontDataSize".}: int32
  fontDataOwnedByAtlas* {...}{.importc: "FontDataOwnedByAtlas".}: bool
  fontNo* {...}{.importc: "FontNo".}: int32
  sizePixels* {...}{.importc: "SizePixels".}: float32
  oversampleH* {...}{.importc: "OversampleH".}: int32
  oversampleV* {...}{.importc: "OversampleV".}: int32
  pixelSnapH* {...}{.importc: "PixelSnapH".}: bool
  glyphExtraSpacing* {...}{.importc: "GlyphExtraSpacing".}: ImVec2
  glyphOffset* {...}{.importc: "GlyphOffset".}: ImVec2
  glyphRanges* {...}{.importc: "GlyphRanges".}: ptr ImWchar
  glyphMinAdvanceX* {...}{.importc: "GlyphMinAdvanceX".}: float32
  glyphMaxAdvanceX* {...}{.importc: "GlyphMaxAdvanceX".}: float32
  mergeMode* {...}{.importc: "MergeMode".}: bool
  fontBuilderFlags* {...}{.importc: "FontBuilderFlags".}: uint32
  rasterizerMultiply* {...}{.importc: "RasterizerMultiply".}: float32
  ellipsisChar* {...}{.importc: "EllipsisChar".}: ImWchar
  name* {...}{.importc: "Name".}: array[40, int8]
  dstFont* {...}{.importc: "DstFont".}: ptr ImFont
ImFontGlyph {...}{.importc: "ImFontGlyph", header: "cimgui.h".} = object
  colored* {...}{.importc: "Colored".}: uint32
  visible* {...}{.importc: "Visible".}: uint32
  codepoint* {...}{.importc: "Codepoint".}: uint32
  advanceX* {...}{.importc: "AdvanceX".}: float32
  x0* {...}{.importc: "X0".}: float32
  y0* {...}{.importc: "Y0".}: float32
  x1* {...}{.importc: "X1".}: float32
  y1* {...}{.importc: "Y1".}: float32
  u0* {...}{.importc: "U0".}: float32
  v0* {...}{.importc: "V0".}: float32
  u1* {...}{.importc: "U1".}: float32
  v1* {...}{.importc: "V1".}: float32
ImFontGlyphRangesBuilder {...}{.importc: "ImFontGlyphRangesBuilder",
                           header: "cimgui.h".} = object
  usedChars* {...}{.importc: "UsedChars".}: ImVector[uint32]
ImGuiColorMod {...}{.importc: "ImGuiColorMod", header: "cimgui.h".} = object
  col* {...}{.importc: "Col".}: ImGuiCol
  backupValue* {...}{.importc: "BackupValue".}: ImVec4
ImGuiContext {...}{.importc: "ImGuiContext", header: "cimgui.h".} = object
  initialized* {...}{.importc: "Initialized".}: bool
  fontAtlasOwnedByContext* {...}{.importc: "FontAtlasOwnedByContext".}: bool
  io* {...}{.importc: "IO".}: ImGuiIO
  style* {...}{.importc: "Style".}: ImGuiStyle
  font* {...}{.importc: "Font".}: ptr ImFont
  fontSize* {...}{.importc: "FontSize".}: float32
  fontBaseSize* {...}{.importc: "FontBaseSize".}: float32
  drawListSharedData* {...}{.importc: "DrawListSharedData".}: ImDrawListSharedData
  time* {...}{.importc: "Time".}: float64
  frameCount* {...}{.importc: "FrameCount".}: int32
  frameCountEnded* {...}{.importc: "FrameCountEnded".}: int32
  frameCountRendered* {...}{.importc: "FrameCountRendered".}: int32
  withinFrameScope* {...}{.importc: "WithinFrameScope".}: bool
  withinFrameScopeWithImplicitWindow* {...}{.importc: "WithinFrameScopeWithImplicitWindow".}: bool
  withinEndChild* {...}{.importc: "WithinEndChild".}: bool
  gcCompactAll* {...}{.importc: "GcCompactAll".}: bool
  testEngineHookItems* {...}{.importc: "TestEngineHookItems".}: bool
  testEngineHookIdInfo* {...}{.importc: "TestEngineHookIdInfo".}: ImGuiID
  testEngine* {...}{.importc: "TestEngine".}: pointer
  windows* {...}{.importc: "Windows".}: ImVector[ptr ImGuiWindow]
  windowsFocusOrder* {...}{.importc: "WindowsFocusOrder".}: ImVector[ptr ImGuiWindow]
  windowsTempSortBuffer* {...}{.importc: "WindowsTempSortBuffer".}: ImVector[
      ptr ImGuiWindow]
  currentWindowStack* {...}{.importc: "CurrentWindowStack".}: ImVector[
      ptr ImGuiWindow]
  windowsById* {...}{.importc: "WindowsById".}: ImGuiStorage
  windowsActiveCount* {...}{.importc: "WindowsActiveCount".}: int32
  currentWindow* {...}{.importc: "CurrentWindow".}: ptr ImGuiWindow
  hoveredWindow* {...}{.importc: "HoveredWindow".}: ptr ImGuiWindow
  hoveredRootWindow* {...}{.importc: "HoveredRootWindow".}: ptr ImGuiWindow
  hoveredWindowUnderMovingWindow* {...}{.importc: "HoveredWindowUnderMovingWindow".}: ptr ImGuiWindow
  movingWindow* {...}{.importc: "MovingWindow".}: ptr ImGuiWindow
  wheelingWindow* {...}{.importc: "WheelingWindow".}: ptr ImGuiWindow
  wheelingWindowRefMousePos* {...}{.importc: "WheelingWindowRefMousePos".}: ImVec2
  wheelingWindowTimer* {...}{.importc: "WheelingWindowTimer".}: float32
  hoveredId* {...}{.importc: "HoveredId".}: ImGuiID
  hoveredIdPreviousFrame* {...}{.importc: "HoveredIdPreviousFrame".}: ImGuiID
  hoveredIdAllowOverlap* {...}{.importc: "HoveredIdAllowOverlap".}: bool
  hoveredIdUsingMouseWheel* {...}{.importc: "HoveredIdUsingMouseWheel".}: bool
  hoveredIdPreviousFrameUsingMouseWheel* {...}{.
      importc: "HoveredIdPreviousFrameUsingMouseWheel".}: bool
  hoveredIdDisabled* {...}{.importc: "HoveredIdDisabled".}: bool
  hoveredIdTimer* {...}{.importc: "HoveredIdTimer".}: float32
  hoveredIdNotActiveTimer* {...}{.importc: "HoveredIdNotActiveTimer".}: float32
  activeId* {...}{.importc: "ActiveId".}: ImGuiID
  activeIdIsAlive* {...}{.importc: "ActiveIdIsAlive".}: ImGuiID
  activeIdTimer* {...}{.importc: "ActiveIdTimer".}: float32
  activeIdIsJustActivated* {...}{.importc: "ActiveIdIsJustActivated".}: bool
  activeIdAllowOverlap* {...}{.importc: "ActiveIdAllowOverlap".}: bool
  activeIdNoClearOnFocusLoss* {...}{.importc: "ActiveIdNoClearOnFocusLoss".}: bool
  activeIdHasBeenPressedBefore* {...}{.importc: "ActiveIdHasBeenPressedBefore".}: bool
  activeIdHasBeenEditedBefore* {...}{.importc: "ActiveIdHasBeenEditedBefore".}: bool
  activeIdHasBeenEditedThisFrame* {...}{.importc: "ActiveIdHasBeenEditedThisFrame".}: bool
  activeIdUsingMouseWheel* {...}{.importc: "ActiveIdUsingMouseWheel".}: bool
  activeIdUsingNavDirMask* {...}{.importc: "ActiveIdUsingNavDirMask".}: uint32
  activeIdUsingNavInputMask* {...}{.importc: "ActiveIdUsingNavInputMask".}: uint32
  activeIdUsingKeyInputMask* {...}{.importc: "ActiveIdUsingKeyInputMask".}: uint64
  activeIdClickOffset* {...}{.importc: "ActiveIdClickOffset".}: ImVec2
  activeIdWindow* {...}{.importc: "ActiveIdWindow".}: ptr ImGuiWindow
  activeIdSource* {...}{.importc: "ActiveIdSource".}: ImGuiInputSource
  activeIdMouseButton* {...}{.importc: "ActiveIdMouseButton".}: int32
  activeIdPreviousFrame* {...}{.importc: "ActiveIdPreviousFrame".}: ImGuiID
  activeIdPreviousFrameIsAlive* {...}{.importc: "ActiveIdPreviousFrameIsAlive".}: bool
  activeIdPreviousFrameHasBeenEditedBefore*
      {...}{.importc: "ActiveIdPreviousFrameHasBeenEditedBefore".}: bool
  activeIdPreviousFrameWindow* {...}{.importc: "ActiveIdPreviousFrameWindow".}: ptr ImGuiWindow
  lastActiveId* {...}{.importc: "LastActiveId".}: ImGuiID
  lastActiveIdTimer* {...}{.importc: "LastActiveIdTimer".}: float32
  nextWindowData* {...}{.importc: "NextWindowData".}: ImGuiNextWindowData
  nextItemData* {...}{.importc: "NextItemData".}: ImGuiNextItemData
  colorStack* {...}{.importc: "ColorStack".}: ImVector[ImGuiColorMod]
  styleVarStack* {...}{.importc: "StyleVarStack".}: ImVector[ImGuiStyleMod]
  fontStack* {...}{.importc: "FontStack".}: ImVector[ptr ImFont]
  focusScopeStack* {...}{.importc: "FocusScopeStack".}: ImVector[ImGuiID]
  itemFlagsStack* {...}{.importc: "ItemFlagsStack".}: ImVector[ImGuiItemFlags]
  groupStack* {...}{.importc: "GroupStack".}: ImVector[ImGuiGroupData]
  openPopupStack* {...}{.importc: "OpenPopupStack".}: ImVector[ImGuiPopupData]
  beginPopupStack* {...}{.importc: "BeginPopupStack".}: ImVector[ImGuiPopupData]
  viewports* {...}{.importc: "Viewports".}: ImVector[ptr ImGuiViewportP]
  navWindow* {...}{.importc: "NavWindow".}: ptr ImGuiWindow
  navId* {...}{.importc: "NavId".}: ImGuiID
  navFocusScopeId* {...}{.importc: "NavFocusScopeId".}: ImGuiID
  navActivateId* {...}{.importc: "NavActivateId".}: ImGuiID
  navActivateDownId* {...}{.importc: "NavActivateDownId".}: ImGuiID
  navActivatePressedId* {...}{.importc: "NavActivatePressedId".}: ImGuiID
  navInputId* {...}{.importc: "NavInputId".}: ImGuiID
  navJustTabbedId* {...}{.importc: "NavJustTabbedId".}: ImGuiID
  navJustMovedToId* {...}{.importc: "NavJustMovedToId".}: ImGuiID
  navJustMovedToFocusScopeId* {...}{.importc: "NavJustMovedToFocusScopeId".}: ImGuiID
  navJustMovedToKeyMods* {...}{.importc: "NavJustMovedToKeyMods".}: ImGuiKeyModFlags
  navNextActivateId* {...}{.importc: "NavNextActivateId".}: ImGuiID
  navInputSource* {...}{.importc: "NavInputSource".}: ImGuiInputSource
  navScoringRect* {...}{.importc: "NavScoringRect".}: ImRect
  navScoringCount* {...}{.importc: "NavScoringCount".}: int32
  navLayer* {...}{.importc: "NavLayer".}: ImGuiNavLayer
  navIdTabCounter* {...}{.importc: "NavIdTabCounter".}: int32
  navIdIsAlive* {...}{.importc: "NavIdIsAlive".}: bool
  navMousePosDirty* {...}{.importc: "NavMousePosDirty".}: bool
  navDisableHighlight* {...}{.importc: "NavDisableHighlight".}: bool
  navDisableMouseHover* {...}{.importc: "NavDisableMouseHover".}: bool
  navAnyRequest* {...}{.importc: "NavAnyRequest".}: bool
  navInitRequest* {...}{.importc: "NavInitRequest".}: bool
  navInitRequestFromMove* {...}{.importc: "NavInitRequestFromMove".}: bool
  navInitResultId* {...}{.importc: "NavInitResultId".}: ImGuiID
  navInitResultRectRel* {...}{.importc: "NavInitResultRectRel".}: ImRect
  navMoveRequest* {...}{.importc: "NavMoveRequest".}: bool
  navMoveRequestFlags* {...}{.importc: "NavMoveRequestFlags".}: ImGuiNavMoveFlags
  navMoveRequestForward* {...}{.importc: "NavMoveRequestForward".}: ImGuiNavForward
  navMoveRequestKeyMods* {...}{.importc: "NavMoveRequestKeyMods".}: ImGuiKeyModFlags
  navMoveDir* {...}{.importc: "NavMoveDir".}: ImGuiDir
  navMoveDirLast* {...}{.importc: "NavMoveDirLast".}: ImGuiDir
  navMoveClipDir* {...}{.importc: "NavMoveClipDir".}: ImGuiDir
  navMoveResultLocal* {...}{.importc: "NavMoveResultLocal".}: ImGuiNavMoveResult
  navMoveResultLocalVisibleSet* {...}{.importc: "NavMoveResultLocalVisibleSet".}: ImGuiNavMoveResult
  navMoveResultOther* {...}{.importc: "NavMoveResultOther".}: ImGuiNavMoveResult
  navWrapRequestWindow* {...}{.importc: "NavWrapRequestWindow".}: ptr ImGuiWindow
  navWrapRequestFlags* {...}{.importc: "NavWrapRequestFlags".}: ImGuiNavMoveFlags
  navWindowingTarget* {...}{.importc: "NavWindowingTarget".}: ptr ImGuiWindow
  navWindowingTargetAnim* {...}{.importc: "NavWindowingTargetAnim".}: ptr ImGuiWindow
  navWindowingListWindow* {...}{.importc: "NavWindowingListWindow".}: ptr ImGuiWindow
  navWindowingTimer* {...}{.importc: "NavWindowingTimer".}: float32
  navWindowingHighlightAlpha* {...}{.importc: "NavWindowingHighlightAlpha".}: float32
  navWindowingToggleLayer* {...}{.importc: "NavWindowingToggleLayer".}: bool
  focusRequestCurrWindow* {...}{.importc: "FocusRequestCurrWindow".}: ptr ImGuiWindow
  focusRequestNextWindow* {...}{.importc: "FocusRequestNextWindow".}: ptr ImGuiWindow
  focusRequestCurrCounterRegular* {...}{.importc: "FocusRequestCurrCounterRegular".}: int32
  focusRequestCurrCounterTabStop* {...}{.importc: "FocusRequestCurrCounterTabStop".}: int32
  focusRequestNextCounterRegular* {...}{.importc: "FocusRequestNextCounterRegular".}: int32
  focusRequestNextCounterTabStop* {...}{.importc: "FocusRequestNextCounterTabStop".}: int32
  focusTabPressed* {...}{.importc: "FocusTabPressed".}: bool
  dimBgRatio* {...}{.importc: "DimBgRatio".}: float32
  mouseCursor* {...}{.importc: "MouseCursor".}: ImGuiMouseCursor
  dragDropActive* {...}{.importc: "DragDropActive".}: bool
  dragDropWithinSource* {...}{.importc: "DragDropWithinSource".}: bool
  dragDropWithinTarget* {...}{.importc: "DragDropWithinTarget".}: bool
  dragDropSourceFlags* {...}{.importc: "DragDropSourceFlags".}: ImGuiDragDropFlags
  dragDropSourceFrameCount* {...}{.importc: "DragDropSourceFrameCount".}: int32
  dragDropMouseButton* {...}{.importc: "DragDropMouseButton".}: int32
  dragDropPayload* {...}{.importc: "DragDropPayload".}: ImGuiPayload
  dragDropTargetRect* {...}{.importc: "DragDropTargetRect".}: ImRect
  dragDropTargetId* {...}{.importc: "DragDropTargetId".}: ImGuiID
  dragDropAcceptFlags* {...}{.importc: "DragDropAcceptFlags".}: ImGuiDragDropFlags
  dragDropAcceptIdCurrRectSurface* {...}{.importc: "DragDropAcceptIdCurrRectSurface".}: float32
  dragDropAcceptIdCurr* {...}{.importc: "DragDropAcceptIdCurr".}: ImGuiID
  dragDropAcceptIdPrev* {...}{.importc: "DragDropAcceptIdPrev".}: ImGuiID
  dragDropAcceptFrameCount* {...}{.importc: "DragDropAcceptFrameCount".}: int32
  dragDropHoldJustPressedId* {...}{.importc: "DragDropHoldJustPressedId".}: ImGuiID
  dragDropPayloadBufHeap* {...}{.importc: "DragDropPayloadBufHeap".}: ImVector[cuchar]
  dragDropPayloadBufLocal* {...}{.importc: "DragDropPayloadBufLocal".}: array[16,
      cuchar]
  currentTable* {...}{.importc: "CurrentTable".}: ptr ImGuiTable
  tables* {...}{.importc: "Tables".}: ImVector[ImGuiTable]
  currentTableStack* {...}{.importc: "CurrentTableStack".}: ImVector[ImGuiPtrOrIndex]
  tablesLastTimeActive* {...}{.importc: "TablesLastTimeActive".}: ImVector[float32]
  drawChannelsTempMergeBuffer* {...}{.importc: "DrawChannelsTempMergeBuffer".}: ImVector[
      ImDrawChannel]
  currentTabBar* {...}{.importc: "CurrentTabBar".}: ptr ImGuiTabBar
  tabBars* {...}{.importc: "TabBars".}: ptr ImPool
  currentTabBarStack* {...}{.importc: "CurrentTabBarStack".}: ImVector[
      ImGuiPtrOrIndex]
  shrinkWidthBuffer* {...}{.importc: "ShrinkWidthBuffer".}: ImVector[
      ImGuiShrinkWidthItem]
  lastValidMousePos* {...}{.importc: "LastValidMousePos".}: ImVec2
  inputTextState* {...}{.importc: "InputTextState".}: ImGuiInputTextState
  inputTextPasswordFont* {...}{.importc: "InputTextPasswordFont".}: ImFont
  tempInputId* {...}{.importc: "TempInputId".}: ImGuiID
  colorEditOptions* {...}{.importc: "ColorEditOptions".}: ImGuiColorEditFlags
  colorEditLastHue* {...}{.importc: "ColorEditLastHue".}: float32
  colorEditLastSat* {...}{.importc: "ColorEditLastSat".}: float32
  colorEditLastColor* {...}{.importc: "ColorEditLastColor".}: array[3, float32]
  colorPickerRef* {...}{.importc: "ColorPickerRef".}: ImVec4
  sliderCurrentAccum* {...}{.importc: "SliderCurrentAccum".}: float32
  sliderCurrentAccumDirty* {...}{.importc: "SliderCurrentAccumDirty".}: bool
  dragCurrentAccumDirty* {...}{.importc: "DragCurrentAccumDirty".}: bool
  dragCurrentAccum* {...}{.importc: "DragCurrentAccum".}: float32
  dragSpeedDefaultRatio* {...}{.importc: "DragSpeedDefaultRatio".}: float32
  scrollbarClickDeltaToGrabCenter* {...}{.importc: "ScrollbarClickDeltaToGrabCenter".}: float32
  tooltipOverrideCount* {...}{.importc: "TooltipOverrideCount".}: int32
  tooltipSlowDelay* {...}{.importc: "TooltipSlowDelay".}: float32
  clipboardHandlerData* {...}{.importc: "ClipboardHandlerData".}: ImVector[int8]
  menusIdSubmittedThisFrame* {...}{.importc: "MenusIdSubmittedThisFrame".}: ImVector[
      ImGuiID]
  platformImePos* {...}{.importc: "PlatformImePos".}: ImVec2
  platformImeLastPos* {...}{.importc: "PlatformImeLastPos".}: ImVec2
  platformLocaleDecimalPoint* {...}{.importc: "PlatformLocaleDecimalPoint".}: int8
  settingsLoaded* {...}{.importc: "SettingsLoaded".}: bool
  settingsDirtyTimer* {...}{.importc: "SettingsDirtyTimer".}: float32
  settingsIniData* {...}{.importc: "SettingsIniData".}: ImGuiTextBuffer
  settingsHandlers* {...}{.importc: "SettingsHandlers".}: ImVector[
      ImGuiSettingsHandler]
  settingsWindows* {...}{.importc: "SettingsWindows".}: ImVector[ImGuiWindowSettings]
  settingsTables* {...}{.importc: "SettingsTables".}: ImVector[ImGuiTableSettings]
  hooks* {...}{.importc: "Hooks".}: ImVector[ImGuiContextHook]
  hookIdNext* {...}{.importc: "HookIdNext".}: ImGuiID
  logEnabled* {...}{.importc: "LogEnabled".}: bool
  logType* {...}{.importc: "LogType".}: ImGuiLogType
  logFile* {...}{.importc: "LogFile".}: ImFileHandle
  logBuffer* {...}{.importc: "LogBuffer".}: ImGuiTextBuffer
  logNextPrefix* {...}{.importc: "LogNextPrefix".}: cstring
  logNextSuffix* {...}{.importc: "LogNextSuffix".}: cstring
  logLinePosY* {...}{.importc: "LogLinePosY".}: float32
  logLineFirstItem* {...}{.importc: "LogLineFirstItem".}: bool
  logDepthRef* {...}{.importc: "LogDepthRef".}: int32
  logDepthToExpand* {...}{.importc: "LogDepthToExpand".}: int32
  logDepthToExpandDefault* {...}{.importc: "LogDepthToExpandDefault".}: int32
  debugItemPickerActive* {...}{.importc: "DebugItemPickerActive".}: bool
  debugItemPickerBreakId* {...}{.importc: "DebugItemPickerBreakId".}: ImGuiID
  debugMetricsConfig* {...}{.importc: "DebugMetricsConfig".}: ImGuiMetricsConfig
  framerateSecPerFrame* {...}{.importc: "FramerateSecPerFrame".}: array[120, float32]
  framerateSecPerFrameIdx* {...}{.importc: "FramerateSecPerFrameIdx".}: int32
  framerateSecPerFrameAccum* {...}{.importc: "FramerateSecPerFrameAccum".}: float32
  wantCaptureMouseNextFrame* {...}{.importc: "WantCaptureMouseNextFrame".}: int32
  wantCaptureKeyboardNextFrame* {...}{.importc: "WantCaptureKeyboardNextFrame".}: int32
  wantTextInputNextFrame* {...}{.importc: "WantTextInputNextFrame".}: int32
  tempBuffer* {...}{.importc: "TempBuffer".}: array[3072 + 1, int8]
ImGuiContextHook {...}{.importc: "ImGuiContextHook", header: "cimgui.h".} = object
  hookId* {...}{.importc: "HookId".}: ImGuiID
  `type`* {...}{.importc: "`type`".}: ImGuiContextHookType
  owner* {...}{.importc: "Owner".}: ImGuiID
  callback* {...}{.importc: "Callback".}: ImGuiContextHookCallback
  userData* {...}{.importc: "UserData".}: pointer
ImGuiDataTypeInfo {...}{.importc: "ImGuiDataTypeInfo", header: "cimgui.h".} = object
  size* {...}{.importc: "Size".}: uint
  name* {...}{.importc: "Name".}: cstring
  printFmt* {...}{.importc: "PrintFmt".}: cstring
  scanFmt* {...}{.importc: "ScanFmt".}: cstring
ImGuiDataTypeTempStorage {...}{.importc: "ImGuiDataTypeTempStorage",
                           header: "cimgui.h".} = object
  data* {...}{.importc: "Data".}: array[8, uint8]
ImGuiGroupData {...}{.importc: "ImGuiGroupData", header: "cimgui.h".} = object
  windowID* {...}{.importc: "WindowID".}: ImGuiID
  backupCursorPos* {...}{.importc: "BackupCursorPos".}: ImVec2
  backupCursorMaxPos* {...}{.importc: "BackupCursorMaxPos".}: ImVec2
  backupIndent* {...}{.importc: "BackupIndent".}: ImVec1
  backupGroupOffset* {...}{.importc: "BackupGroupOffset".}: ImVec1
  backupCurrLineSize* {...}{.importc: "BackupCurrLineSize".}: ImVec2
  backupCurrLineTextBaseOffset* {...}{.importc: "BackupCurrLineTextBaseOffset".}: float32
  backupActiveIdIsAlive* {...}{.importc: "BackupActiveIdIsAlive".}: ImGuiID
  backupActiveIdPreviousFrameIsAlive* {...}{.importc: "BackupActiveIdPreviousFrameIsAlive".}: bool
  emitItem* {...}{.importc: "EmitItem".}: bool
ImGuiIO {...}{.importc: "ImGuiIO", header: "cimgui.h".} = object
  configFlags* {...}{.importc: "ConfigFlags".}: ImGuiConfigFlags
  backendFlags* {...}{.importc: "BackendFlags".}: ImGuiBackendFlags
  displaySize* {...}{.importc: "DisplaySize".}: ImVec2
  deltaTime* {...}{.importc: "DeltaTime".}: float32
  iniSavingRate* {...}{.importc: "IniSavingRate".}: float32
  iniFilename* {...}{.importc: "IniFilename".}: cstring
  logFilename* {...}{.importc: "LogFilename".}: cstring
  mouseDoubleClickTime* {...}{.importc: "MouseDoubleClickTime".}: float32
  mouseDoubleClickMaxDist* {...}{.importc: "MouseDoubleClickMaxDist".}: float32
  mouseDragThreshold* {...}{.importc: "MouseDragThreshold".}: float32
  keyMap* {...}{.importc: "KeyMap".}: array[22, int32]
  keyRepeatDelay* {...}{.importc: "KeyRepeatDelay".}: float32
  keyRepeatRate* {...}{.importc: "KeyRepeatRate".}: float32
  userData* {...}{.importc: "UserData".}: pointer
  fonts* {...}{.importc: "Fonts".}: ptr ImFontAtlas
  fontGlobalScale* {...}{.importc: "FontGlobalScale".}: float32
  fontAllowUserScaling* {...}{.importc: "FontAllowUserScaling".}: bool
  fontDefault* {...}{.importc: "FontDefault".}: ptr ImFont
  displayFramebufferScale* {...}{.importc: "DisplayFramebufferScale".}: ImVec2
  mouseDrawCursor* {...}{.importc: "MouseDrawCursor".}: bool
  configMacOSXBehaviors* {...}{.importc: "ConfigMacOSXBehaviors".}: bool
  configInputTextCursorBlink* {...}{.importc: "ConfigInputTextCursorBlink".}: bool
  configDragClickToInputText* {...}{.importc: "ConfigDragClickToInputText".}: bool
  configWindowsResizeFromEdges* {...}{.importc: "ConfigWindowsResizeFromEdges".}: bool
  configWindowsMoveFromTitleBarOnly* {...}{.importc: "ConfigWindowsMoveFromTitleBarOnly".}: bool
  configMemoryCompactTimer* {...}{.importc: "ConfigMemoryCompactTimer".}: float32
  backendPlatformName* {...}{.importc: "BackendPlatformName".}: cstring
  backendRendererName* {...}{.importc: "BackendRendererName".}: cstring
  backendPlatformUserData* {...}{.importc: "BackendPlatformUserData".}: pointer
  backendRendererUserData* {...}{.importc: "BackendRendererUserData".}: pointer
  backendLanguageUserData* {...}{.importc: "BackendLanguageUserData".}: pointer
  getClipboardTextFn* {...}{.importc: "GetClipboardTextFn".}: proc (
      user_data: pointer): cstring {...}{.cdecl, varargs.}
  setClipboardTextFn* {...}{.importc: "SetClipboardTextFn".}: proc (
      user_data: pointer; text: cstring): void {...}{.cdecl, varargs.}
  clipboardUserData* {...}{.importc: "ClipboardUserData".}: pointer
  imeSetInputScreenPosFn* {...}{.importc: "ImeSetInputScreenPosFn".}: proc (x: int32;
      y: int32): void {...}{.cdecl, varargs.}
  imeWindowHandle* {...}{.importc: "ImeWindowHandle".}: pointer
  mousePos* {...}{.importc: "MousePos".}: ImVec2
  mouseDown* {...}{.importc: "MouseDown".}: array[5, bool]
  mouseWheel* {...}{.importc: "MouseWheel".}: float32
  mouseWheelH* {...}{.importc: "MouseWheelH".}: float32
  keyCtrl* {...}{.importc: "KeyCtrl".}: bool
  keyShift* {...}{.importc: "KeyShift".}: bool
  keyAlt* {...}{.importc: "KeyAlt".}: bool
  keySuper* {...}{.importc: "KeySuper".}: bool
  keysDown* {...}{.importc: "KeysDown".}: array[512, bool]
  navInputs* {...}{.importc: "NavInputs".}: array[21, float32]
  wantCaptureMouse* {...}{.importc: "WantCaptureMouse".}: bool
  wantCaptureKeyboard* {...}{.importc: "WantCaptureKeyboard".}: bool
  wantTextInput* {...}{.importc: "WantTextInput".}: bool
  wantSetMousePos* {...}{.importc: "WantSetMousePos".}: bool
  wantSaveIniSettings* {...}{.importc: "WantSaveIniSettings".}: bool
  navActive* {...}{.importc: "NavActive".}: bool
  navVisible* {...}{.importc: "NavVisible".}: bool
  framerate* {...}{.importc: "Framerate".}: float32
  metricsRenderVertices* {...}{.importc: "MetricsRenderVertices".}: int32
  metricsRenderIndices* {...}{.importc: "MetricsRenderIndices".}: int32
  metricsRenderWindows* {...}{.importc: "MetricsRenderWindows".}: int32
  metricsActiveWindows* {...}{.importc: "MetricsActiveWindows".}: int32
  metricsActiveAllocations* {...}{.importc: "MetricsActiveAllocations".}: int32
  mouseDelta* {...}{.importc: "MouseDelta".}: ImVec2
  keyMods* {...}{.importc: "KeyMods".}: ImGuiKeyModFlags
  mousePosPrev* {...}{.importc: "MousePosPrev".}: ImVec2
  mouseClickedPos* {...}{.importc: "MouseClickedPos".}: array[5, ImVec2]
  mouseClickedTime* {...}{.importc: "MouseClickedTime".}: array[5, float64]
  mouseClicked* {...}{.importc: "MouseClicked".}: array[5, bool]
  mouseDoubleClicked* {...}{.importc: "MouseDoubleClicked".}: array[5, bool]
  mouseReleased* {...}{.importc: "MouseReleased".}: array[5, bool]
  mouseDownOwned* {...}{.importc: "MouseDownOwned".}: array[5, bool]
  mouseDownWasDoubleClick* {...}{.importc: "MouseDownWasDoubleClick".}: array[5, bool]
  mouseDownDuration* {...}{.importc: "MouseDownDuration".}: array[5, float32]
  mouseDownDurationPrev* {...}{.importc: "MouseDownDurationPrev".}: array[5, float32]
  mouseDragMaxDistanceAbs* {...}{.importc: "MouseDragMaxDistanceAbs".}: array[5,
      ImVec2]
  mouseDragMaxDistanceSqr* {...}{.importc: "MouseDragMaxDistanceSqr".}: array[5,
      float32]
  keysDownDuration* {...}{.importc: "KeysDownDuration".}: array[512, float32]
  keysDownDurationPrev* {...}{.importc: "KeysDownDurationPrev".}: array[512, float32]
  navInputsDownDuration* {...}{.importc: "NavInputsDownDuration".}: array[21, float32]
  navInputsDownDurationPrev* {...}{.importc: "NavInputsDownDurationPrev".}: array[21,
      float32]
  penPressure* {...}{.importc: "PenPressure".}: float32
  inputQueueSurrogate* {...}{.importc: "InputQueueSurrogate".}: ImWchar16
  inputQueueCharacters* {...}{.importc: "InputQueueCharacters".}: ImVector[ImWchar]
ImGuiInputTextCallbackData {...}{.importc: "ImGuiInputTextCallbackData",
                             header: "cimgui.h".} = object
  eventFlag* {...}{.importc: "EventFlag".}: ImGuiInputTextFlags
  flags* {...}{.importc: "Flags".}: ImGuiInputTextFlags
  userData* {...}{.importc: "UserData".}: pointer
  eventChar* {...}{.importc: "EventChar".}: ImWchar
  eventKey* {...}{.importc: "EventKey".}: ImGuiKey
  buf* {...}{.importc: "Buf".}: cstring
  bufTextLen* {...}{.importc: "BufTextLen".}: int32
  bufSize* {...}{.importc: "BufSize".}: int32
  bufDirty* {...}{.importc: "BufDirty".}: bool
  cursorPos* {...}{.importc: "CursorPos".}: int32
  selectionStart* {...}{.importc: "SelectionStart".}: int32
  selectionEnd* {...}{.importc: "SelectionEnd".}: int32
ImGuiInputTextState {...}{.importc: "ImGuiInputTextState", header: "cimgui.h".} = object
  id* {...}{.importc: "ID".}: ImGuiID
  curLenW* {...}{.importc: "CurLenW".}: int32
  curLenA* {...}{.importc: "CurLenA".}: int32
  textW* {...}{.importc: "TextW".}: ImVector[ImWchar]
  textA* {...}{.importc: "TextA".}: ImVector[int8]
  initialTextA* {...}{.importc: "InitialTextA".}: ImVector[int8]
  textAIsValid* {...}{.importc: "TextAIsValid".}: bool
  bufCapacityA* {...}{.importc: "BufCapacityA".}: int32
  scrollX* {...}{.importc: "ScrollX".}: float32
  stb* {...}{.importc: "Stb".}: STB_TexteditState
  cursorAnim* {...}{.importc: "CursorAnim".}: float32
  cursorFollow* {...}{.importc: "CursorFollow".}: bool
  selectedAllMouseLock* {...}{.importc: "SelectedAllMouseLock".}: bool
  edited* {...}{.importc: "Edited".}: bool
  userFlags* {...}{.importc: "UserFlags".}: ImGuiInputTextFlags
  userCallback* {...}{.importc: "UserCallback".}: ImGuiInputTextCallback
  userCallbackData* {...}{.importc: "UserCallbackData".}: pointer
ImGuiLastItemDataBackup {...}{.importc: "ImGuiLastItemDataBackup", header: "cimgui.h".} = object
  lastItemId* {...}{.importc: "LastItemId".}: ImGuiID
  lastItemStatusFlags* {...}{.importc: "LastItemStatusFlags".}: ImGuiItemStatusFlags
  lastItemRect* {...}{.importc: "LastItemRect".}: ImRect
  lastItemDisplayRect* {...}{.importc: "LastItemDisplayRect".}: ImRect
ImGuiListClipper {...}{.importc: "ImGuiListClipper", header: "cimgui.h".} = object
  displayStart* {...}{.importc: "DisplayStart".}: int32
  displayEnd* {...}{.importc: "DisplayEnd".}: int32
  itemsCount* {...}{.importc: "ItemsCount".}: int32
  stepNo* {...}{.importc: "StepNo".}: int32
  itemsFrozen* {...}{.importc: "ItemsFrozen".}: int32
  itemsHeight* {...}{.importc: "ItemsHeight".}: float32
  startPosY* {...}{.importc: "StartPosY".}: float32
ImGuiMenuColumns {...}{.importc: "ImGuiMenuColumns", header: "cimgui.h".} = object
  spacing* {...}{.importc: "Spacing".}: float32
  width* {...}{.importc: "Width".}: float32
  nextWidth* {...}{.importc: "NextWidth".}: float32
  pos* {...}{.importc: "Pos".}: array[3, float32]
  nextWidths* {...}{.importc: "NextWidths".}: array[3, float32]
ImGuiMetricsConfig {...}{.importc: "ImGuiMetricsConfig", header: "cimgui.h".} = object
  showWindowsRects* {...}{.importc: "ShowWindowsRects".}: bool
  showWindowsBeginOrder* {...}{.importc: "ShowWindowsBeginOrder".}: bool
  showTablesRects* {...}{.importc: "ShowTablesRects".}: bool
  showDrawCmdMesh* {...}{.importc: "ShowDrawCmdMesh".}: bool
  showDrawCmdBoundingBoxes* {...}{.importc: "ShowDrawCmdBoundingBoxes".}: bool
  showWindowsRectsType* {...}{.importc: "ShowWindowsRectsType".}: int32
  showTablesRectsType* {...}{.importc: "ShowTablesRectsType".}: int32
ImGuiNavMoveResult {...}{.importc: "ImGuiNavMoveResult", header: "cimgui.h".} = object
  window* {...}{.importc: "Window".}: ptr ImGuiWindow
  id* {...}{.importc: "ID".}: ImGuiID
  focusScopeId* {...}{.importc: "FocusScopeId".}: ImGuiID
  distBox* {...}{.importc: "DistBox".}: float32
  distCenter* {...}{.importc: "DistCenter".}: float32
  distAxial* {...}{.importc: "DistAxial".}: float32
  rectRel* {...}{.importc: "RectRel".}: ImRect
ImGuiNextItemData {...}{.importc: "ImGuiNextItemData", header: "cimgui.h".} = object
  flags* {...}{.importc: "Flags".}: ImGuiNextItemDataFlags
  width* {...}{.importc: "Width".}: float32
  focusScopeId* {...}{.importc: "FocusScopeId".}: ImGuiID
  openCond* {...}{.importc: "OpenCond".}: ImGuiCond
  openVal* {...}{.importc: "OpenVal".}: bool
ImGuiNextWindowData {...}{.importc: "ImGuiNextWindowData", header: "cimgui.h".} = object
  flags* {...}{.importc: "Flags".}: ImGuiNextWindowDataFlags
  posCond* {...}{.importc: "PosCond".}: ImGuiCond
  sizeCond* {...}{.importc: "SizeCond".}: ImGuiCond
  collapsedCond* {...}{.importc: "CollapsedCond".}: ImGuiCond
  posVal* {...}{.importc: "PosVal".}: ImVec2
  posPivotVal* {...}{.importc: "PosPivotVal".}: ImVec2
  sizeVal* {...}{.importc: "SizeVal".}: ImVec2
  contentSizeVal* {...}{.importc: "ContentSizeVal".}: ImVec2
  scrollVal* {...}{.importc: "ScrollVal".}: ImVec2
  collapsedVal* {...}{.importc: "CollapsedVal".}: bool
  sizeConstraintRect* {...}{.importc: "SizeConstraintRect".}: ImRect
  sizeCallback* {...}{.importc: "SizeCallback".}: ImGuiSizeCallback
  sizeCallbackUserData* {...}{.importc: "SizeCallbackUserData".}: pointer
  bgAlphaVal* {...}{.importc: "BgAlphaVal".}: float32
  menuBarOffsetMinVal* {...}{.importc: "MenuBarOffsetMinVal".}: ImVec2
ImGuiOldColumnData {...}{.importc: "ImGuiOldColumnData", header: "cimgui.h".} = object
  offsetNorm* {...}{.importc: "OffsetNorm".}: float32
  offsetNormBeforeResize* {...}{.importc: "OffsetNormBeforeResize".}: float32
  flags* {...}{.importc: "Flags".}: ImGuiOldColumnFlags
  clipRect* {...}{.importc: "ClipRect".}: ImRect
ImGuiOldColumns {...}{.importc: "ImGuiOldColumns", header: "cimgui.h".} = object
  id* {...}{.importc: "ID".}: ImGuiID
  flags* {...}{.importc: "Flags".}: ImGuiOldColumnFlags
  isFirstFrame* {...}{.importc: "IsFirstFrame".}: bool
  isBeingResized* {...}{.importc: "IsBeingResized".}: bool
  current* {...}{.importc: "Current".}: int32
  count* {...}{.importc: "Count".}: int32
  offMinX* {...}{.importc: "OffMinX".}: float32
  offMaxX* {...}{.importc: "OffMaxX".}: float32
  lineMinY* {...}{.importc: "LineMinY".}: float32
  lineMaxY* {...}{.importc: "LineMaxY".}: float32
  hostCursorPosY* {...}{.importc: "HostCursorPosY".}: float32
  hostCursorMaxPosX* {...}{.importc: "HostCursorMaxPosX".}: float32
  hostInitialClipRect* {...}{.importc: "HostInitialClipRect".}: ImRect
  hostBackupClipRect* {...}{.importc: "HostBackupClipRect".}: ImRect
  hostBackupParentWorkRect* {...}{.importc: "HostBackupParentWorkRect".}: ImRect
  columns* {...}{.importc: "Columns".}: ImVector[ImGuiOldColumnData]
  splitter* {...}{.importc: "Splitter".}: ImDrawListSplitter
ImGuiOnceUponAFrame {...}{.importc: "ImGuiOnceUponAFrame", header: "cimgui.h".} = object
  refFrame* {...}{.importc: "RefFrame".}: int32
ImGuiPayload {...}{.importc: "ImGuiPayload", header: "cimgui.h".} = object
  data* {...}{.importc: "Data".}: pointer
  dataSize* {...}{.importc: "DataSize".}: int32
  sourceId* {...}{.importc: "SourceId".}: ImGuiID
  sourceParentId* {...}{.importc: "SourceParentId".}: ImGuiID
  dataFrameCount* {...}{.importc: "DataFrameCount".}: int32
  dataType* {...}{.importc: "DataType".}: array[32 + 1, int8]
  preview* {...}{.importc: "Preview".}: bool
  delivery* {...}{.importc: "Delivery".}: bool
ImGuiPopupData {...}{.importc: "ImGuiPopupData", header: "cimgui.h".} = object
  popupId* {...}{.importc: "PopupId".}: ImGuiID
  window* {...}{.importc: "Window".}: ptr ImGuiWindow
  sourceWindow* {...}{.importc: "SourceWindow".}: ptr ImGuiWindow
  openFrameCount* {...}{.importc: "OpenFrameCount".}: int32
  openParentId* {...}{.importc: "OpenParentId".}: ImGuiID
  openPopupPos* {...}{.importc: "OpenPopupPos".}: ImVec2
  openMousePos* {...}{.importc: "OpenMousePos".}: ImVec2
ImGuiPtrOrIndex {...}{.importc: "ImGuiPtrOrIndex", header: "cimgui.h".} = object
  `ptr`* {...}{.importc: "`ptr`".}: pointer
  index* {...}{.importc: "Index".}: int32
ImGuiSettingsHandler {...}{.importc: "ImGuiSettingsHandler", header: "cimgui.h".} = object
  typeName* {...}{.importc: "TypeName".}: cstring
  typeHash* {...}{.importc: "TypeHash".}: ImGuiID
  clearAllFn* {...}{.importc: "ClearAllFn".}: proc (ctx: ptr ImGuiContext;
      handler: ptr ImGuiSettingsHandler): void {...}{.cdecl, varargs.}
  readInitFn* {...}{.importc: "ReadInitFn".}: proc (ctx: ptr ImGuiContext;
      handler: ptr ImGuiSettingsHandler): void {...}{.cdecl, varargs.}
  readOpenFn* {...}{.importc: "ReadOpenFn".}: proc (ctx: ptr ImGuiContext;
      handler: ptr ImGuiSettingsHandler; name: cstring): pointer {...}{.cdecl,
      varargs.}
  readLineFn* {...}{.importc: "ReadLineFn".}: proc (ctx: ptr ImGuiContext;
      handler: ptr ImGuiSettingsHandler; entry: pointer; line: cstring): void {...}{.
      cdecl, varargs.}
  applyAllFn* {...}{.importc: "ApplyAllFn".}: proc (ctx: ptr ImGuiContext;
      handler: ptr ImGuiSettingsHandler): void {...}{.cdecl, varargs.}
  writeAllFn* {...}{.importc: "WriteAllFn".}: proc (ctx: ptr ImGuiContext;
      handler: ptr ImGuiSettingsHandler; out_buf: ptr ImGuiTextBuffer): void {...}{.
      cdecl, varargs.}
  userData* {...}{.importc: "UserData".}: pointer
ImGuiShrinkWidthItem {...}{.importc: "ImGuiShrinkWidthItem", header: "cimgui.h".} = object
  index* {...}{.importc: "Index".}: int32
  width* {...}{.importc: "Width".}: float32
ImGuiSizeCallbackData {...}{.importc: "ImGuiSizeCallbackData", header: "cimgui.h".} = object
  userData* {...}{.importc: "UserData".}: pointer
  pos* {...}{.importc: "Pos".}: ImVec2
  currentSize* {...}{.importc: "CurrentSize".}: ImVec2
  desiredSize* {...}{.importc: "DesiredSize".}: ImVec2
ImGuiStackSizes {...}{.importc: "ImGuiStackSizes", header: "cimgui.h".} = object
  sizeOfIDStack* {...}{.importc: "SizeOfIDStack".}: int16
  sizeOfColorStack* {...}{.importc: "SizeOfColorStack".}: int16
  sizeOfStyleVarStack* {...}{.importc: "SizeOfStyleVarStack".}: int16
  sizeOfFontStack* {...}{.importc: "SizeOfFontStack".}: int16
  sizeOfFocusScopeStack* {...}{.importc: "SizeOfFocusScopeStack".}: int16
  sizeOfGroupStack* {...}{.importc: "SizeOfGroupStack".}: int16
  sizeOfBeginPopupStack* {...}{.importc: "SizeOfBeginPopupStack".}: int16
ImGuiStorage {...}{.importc: "ImGuiStorage", header: "cimgui.h".} = object
  data* {...}{.importc: "Data".}: ImVector[ImGuiStoragePair]
ImGuiStyle {...}{.importc: "ImGuiStyle", header: "cimgui.h".} = object
  alpha* {...}{.importc: "Alpha".}: float32
  windowPadding* {...}{.importc: "WindowPadding".}: ImVec2
  windowRounding* {...}{.importc: "WindowRounding".}: float32
  windowBorderSize* {...}{.importc: "WindowBorderSize".}: float32
  windowMinSize* {...}{.importc: "WindowMinSize".}: ImVec2
  windowTitleAlign* {...}{.importc: "WindowTitleAlign".}: ImVec2
  windowMenuButtonPosition* {...}{.importc: "WindowMenuButtonPosition".}: ImGuiDir
  childRounding* {...}{.importc: "ChildRounding".}: float32
  childBorderSize* {...}{.importc: "ChildBorderSize".}: float32
  popupRounding* {...}{.importc: "PopupRounding".}: float32
  popupBorderSize* {...}{.importc: "PopupBorderSize".}: float32
  framePadding* {...}{.importc: "FramePadding".}: ImVec2
  frameRounding* {...}{.importc: "FrameRounding".}: float32
  frameBorderSize* {...}{.importc: "FrameBorderSize".}: float32
  itemSpacing* {...}{.importc: "ItemSpacing".}: ImVec2
  itemInnerSpacing* {...}{.importc: "ItemInnerSpacing".}: ImVec2
  cellPadding* {...}{.importc: "CellPadding".}: ImVec2
  touchExtraPadding* {...}{.importc: "TouchExtraPadding".}: ImVec2
  indentSpacing* {...}{.importc: "IndentSpacing".}: float32
  columnsMinSpacing* {...}{.importc: "ColumnsMinSpacing".}: float32
  scrollbarSize* {...}{.importc: "ScrollbarSize".}: float32
  scrollbarRounding* {...}{.importc: "ScrollbarRounding".}: float32
  grabMinSize* {...}{.importc: "GrabMinSize".}: float32
  grabRounding* {...}{.importc: "GrabRounding".}: float32
  logSliderDeadzone* {...}{.importc: "LogSliderDeadzone".}: float32
  tabRounding* {...}{.importc: "TabRounding".}: float32
  tabBorderSize* {...}{.importc: "TabBorderSize".}: float32
  tabMinWidthForCloseButton* {...}{.importc: "TabMinWidthForCloseButton".}: float32
  colorButtonPosition* {...}{.importc: "ColorButtonPosition".}: ImGuiDir
  buttonTextAlign* {...}{.importc: "ButtonTextAlign".}: ImVec2
  selectableTextAlign* {...}{.importc: "SelectableTextAlign".}: ImVec2
  displayWindowPadding* {...}{.importc: "DisplayWindowPadding".}: ImVec2
  displaySafeAreaPadding* {...}{.importc: "DisplaySafeAreaPadding".}: ImVec2
  mouseCursorScale* {...}{.importc: "MouseCursorScale".}: float32
  antiAliasedLines* {...}{.importc: "AntiAliasedLines".}: bool
  antiAliasedLinesUseTex* {...}{.importc: "AntiAliasedLinesUseTex".}: bool
  antiAliasedFill* {...}{.importc: "AntiAliasedFill".}: bool
  curveTessellationTol* {...}{.importc: "CurveTessellationTol".}: float32
  circleSegmentMaxError* {...}{.importc: "CircleSegmentMaxError".}: float32
  colors* {...}{.importc: "Colors".}: array[53, ImVec4]
ImGuiTabBar {...}{.importc: "ImGuiTabBar", header: "cimgui.h".} = object
  tabs* {...}{.importc: "Tabs".}: ImVector[ImGuiTabItem]
  flags* {...}{.importc: "Flags".}: ImGuiTabBarFlags
  id* {...}{.importc: "ID".}: ImGuiID
  selectedTabId* {...}{.importc: "SelectedTabId".}: ImGuiID
  nextSelectedTabId* {...}{.importc: "NextSelectedTabId".}: ImGuiID
  visibleTabId* {...}{.importc: "VisibleTabId".}: ImGuiID
  currFrameVisible* {...}{.importc: "CurrFrameVisible".}: int32
  prevFrameVisible* {...}{.importc: "PrevFrameVisible".}: int32
  barRect* {...}{.importc: "BarRect".}: ImRect
  currTabsContentsHeight* {...}{.importc: "CurrTabsContentsHeight".}: float32
  prevTabsContentsHeight* {...}{.importc: "PrevTabsContentsHeight".}: float32
  widthAllTabs* {...}{.importc: "WidthAllTabs".}: float32
  widthAllTabsIdeal* {...}{.importc: "WidthAllTabsIdeal".}: float32
  scrollingAnim* {...}{.importc: "ScrollingAnim".}: float32
  scrollingTarget* {...}{.importc: "ScrollingTarget".}: float32
  scrollingTargetDistToVisibility* {...}{.importc: "ScrollingTargetDistToVisibility".}: float32
  scrollingSpeed* {...}{.importc: "ScrollingSpeed".}: float32
  scrollingRectMinX* {...}{.importc: "ScrollingRectMinX".}: float32
  scrollingRectMaxX* {...}{.importc: "ScrollingRectMaxX".}: float32
  reorderRequestTabId* {...}{.importc: "ReorderRequestTabId".}: ImGuiID
  reorderRequestDir* {...}{.importc: "ReorderRequestDir".}: int8
  beginCount* {...}{.importc: "BeginCount".}: int8
  wantLayout* {...}{.importc: "WantLayout".}: bool
  visibleTabWasSubmitted* {...}{.importc: "VisibleTabWasSubmitted".}: bool
  tabsAddedNew* {...}{.importc: "TabsAddedNew".}: bool
  tabsActiveCount* {...}{.importc: "TabsActiveCount".}: int16
  lastTabItemIdx* {...}{.importc: "LastTabItemIdx".}: int16
  itemSpacingY* {...}{.importc: "ItemSpacingY".}: float32
  framePadding* {...}{.importc: "FramePadding".}: ImVec2
  backupCursorPos* {...}{.importc: "BackupCursorPos".}: ImVec2
  tabsNames* {...}{.importc: "TabsNames".}: ImGuiTextBuffer
ImGuiTabItem {...}{.importc: "ImGuiTabItem", header: "cimgui.h".} = object
  id* {...}{.importc: "ID".}: ImGuiID
  flags* {...}{.importc: "Flags".}: ImGuiTabItemFlags
  lastFrameVisible* {...}{.importc: "LastFrameVisible".}: int32
  lastFrameSelected* {...}{.importc: "LastFrameSelected".}: int32
  offset* {...}{.importc: "Offset".}: float32
  width* {...}{.importc: "Width".}: float32
  contentWidth* {...}{.importc: "ContentWidth".}: float32
  nameOffset* {...}{.importc: "NameOffset".}: int16
  beginOrder* {...}{.importc: "BeginOrder".}: int16
  indexDuringLayout* {...}{.importc: "IndexDuringLayout".}: int16
  wantClose* {...}{.importc: "WantClose".}: bool
ImGuiTable {...}{.importc: "ImGuiTable", header: "cimgui.h".} = object
  id* {...}{.importc: "ID".}: ImGuiID
  flags* {...}{.importc: "Flags".}: ImGuiTableFlags
  rawData* {...}{.importc: "RawData".}: pointer
  columns* {...}{.importc: "Columns".}: ImVector[ImGuiTableColumn]
  displayOrderToIndex* {...}{.importc: "DisplayOrderToIndex".}: ImVector[
      ImGuiTableColumnIdx]
  rowCellData* {...}{.importc: "RowCellData".}: ImVector[ImGuiTableCellData]
  enabledMaskByDisplayOrder* {...}{.importc: "EnabledMaskByDisplayOrder".}: uint64
  enabledMaskByIndex* {...}{.importc: "EnabledMaskByIndex".}: uint64
  visibleMaskByIndex* {...}{.importc: "VisibleMaskByIndex".}: uint64
  requestOutputMaskByIndex* {...}{.importc: "RequestOutputMaskByIndex".}: uint64
  settingsLoadedFlags* {...}{.importc: "SettingsLoadedFlags".}: ImGuiTableFlags
  settingsOffset* {...}{.importc: "SettingsOffset".}: int32
  lastFrameActive* {...}{.importc: "LastFrameActive".}: int32
  columnsCount* {...}{.importc: "ColumnsCount".}: int32
  currentRow* {...}{.importc: "CurrentRow".}: int32
  currentColumn* {...}{.importc: "CurrentColumn".}: int32
  instanceCurrent* {...}{.importc: "InstanceCurrent".}: int16
  instanceInteracted* {...}{.importc: "InstanceInteracted".}: int16
  rowPosY1* {...}{.importc: "RowPosY1".}: float32
  rowPosY2* {...}{.importc: "RowPosY2".}: float32
  rowMinHeight* {...}{.importc: "RowMinHeight".}: float32
  rowTextBaseline* {...}{.importc: "RowTextBaseline".}: float32
  rowIndentOffsetX* {...}{.importc: "RowIndentOffsetX".}: float32
  rowFlags* {...}{.importc: "RowFlags".}: ImGuiTableRowFlags
  lastRowFlags* {...}{.importc: "LastRowFlags".}: ImGuiTableRowFlags
  rowBgColorCounter* {...}{.importc: "RowBgColorCounter".}: int32
  rowBgColor* {...}{.importc: "RowBgColor".}: array[2, uint32]
  borderColorStrong* {...}{.importc: "BorderColorStrong".}: uint32
  borderColorLight* {...}{.importc: "BorderColorLight".}: uint32
  borderX1* {...}{.importc: "BorderX1".}: float32
  borderX2* {...}{.importc: "BorderX2".}: float32
  hostIndentX* {...}{.importc: "HostIndentX".}: float32
  minColumnWidth* {...}{.importc: "MinColumnWidth".}: float32
  outerPaddingX* {...}{.importc: "OuterPaddingX".}: float32
  cellPaddingX* {...}{.importc: "CellPaddingX".}: float32
  cellPaddingY* {...}{.importc: "CellPaddingY".}: float32
  cellSpacingX1* {...}{.importc: "CellSpacingX1".}: float32
  cellSpacingX2* {...}{.importc: "CellSpacingX2".}: float32
  lastOuterHeight* {...}{.importc: "LastOuterHeight".}: float32
  lastFirstRowHeight* {...}{.importc: "LastFirstRowHeight".}: float32
  innerWidth* {...}{.importc: "InnerWidth".}: float32
  columnsGivenWidth* {...}{.importc: "ColumnsGivenWidth".}: float32
  columnsAutoFitWidth* {...}{.importc: "ColumnsAutoFitWidth".}: float32
  resizedColumnNextWidth* {...}{.importc: "ResizedColumnNextWidth".}: float32
  resizeLockMinContentsX2* {...}{.importc: "ResizeLockMinContentsX2".}: float32
  refScale* {...}{.importc: "RefScale".}: float32
  outerRect* {...}{.importc: "OuterRect".}: ImRect
  innerRect* {...}{.importc: "InnerRect".}: ImRect
  workRect* {...}{.importc: "WorkRect".}: ImRect
  innerClipRect* {...}{.importc: "InnerClipRect".}: ImRect
  bgClipRect* {...}{.importc: "BgClipRect".}: ImRect
  bg0ClipRectForDrawCmd* {...}{.importc: "Bg0ClipRectForDrawCmd".}: ImRect
  bg2ClipRectForDrawCmd* {...}{.importc: "Bg2ClipRectForDrawCmd".}: ImRect
  hostClipRect* {...}{.importc: "HostClipRect".}: ImRect
  hostBackupWorkRect* {...}{.importc: "HostBackupWorkRect".}: ImRect
  hostBackupParentWorkRect* {...}{.importc: "HostBackupParentWorkRect".}: ImRect
  hostBackupInnerClipRect* {...}{.importc: "HostBackupInnerClipRect".}: ImRect
  hostBackupPrevLineSize* {...}{.importc: "HostBackupPrevLineSize".}: ImVec2
  hostBackupCurrLineSize* {...}{.importc: "HostBackupCurrLineSize".}: ImVec2
  hostBackupCursorMaxPos* {...}{.importc: "HostBackupCursorMaxPos".}: ImVec2
  userOuterSize* {...}{.importc: "UserOuterSize".}: ImVec2
  hostBackupColumnsOffset* {...}{.importc: "HostBackupColumnsOffset".}: ImVec1
  hostBackupItemWidth* {...}{.importc: "HostBackupItemWidth".}: float32
  hostBackupItemWidthStackSize* {...}{.importc: "HostBackupItemWidthStackSize".}: int32
  outerWindow* {...}{.importc: "OuterWindow".}: ptr ImGuiWindow
  innerWindow* {...}{.importc: "InnerWindow".}: ptr ImGuiWindow
  columnsNames* {...}{.importc: "ColumnsNames".}: ImGuiTextBuffer
  drawSplitter* {...}{.importc: "DrawSplitter".}: ImDrawListSplitter
  sortSpecsSingle* {...}{.importc: "SortSpecsSingle".}: ImGuiTableColumnSortSpecs
  sortSpecsMulti* {...}{.importc: "SortSpecsMulti".}: ImVector[
      ImGuiTableColumnSortSpecs]
  sortSpecs* {...}{.importc: "SortSpecs".}: ImGuiTableSortSpecs
  sortSpecsCount* {...}{.importc: "SortSpecsCount".}: ImGuiTableColumnIdx
  columnsEnabledCount* {...}{.importc: "ColumnsEnabledCount".}: ImGuiTableColumnIdx
  columnsEnabledFixedCount* {...}{.importc: "ColumnsEnabledFixedCount".}: ImGuiTableColumnIdx
  declColumnsCount* {...}{.importc: "DeclColumnsCount".}: ImGuiTableColumnIdx
  hoveredColumnBody* {...}{.importc: "HoveredColumnBody".}: ImGuiTableColumnIdx
  hoveredColumnBorder* {...}{.importc: "HoveredColumnBorder".}: ImGuiTableColumnIdx
  autoFitSingleColumn* {...}{.importc: "AutoFitSingleColumn".}: ImGuiTableColumnIdx
  resizedColumn* {...}{.importc: "ResizedColumn".}: ImGuiTableColumnIdx
  lastResizedColumn* {...}{.importc: "LastResizedColumn".}: ImGuiTableColumnIdx
  heldHeaderColumn* {...}{.importc: "HeldHeaderColumn".}: ImGuiTableColumnIdx
  reorderColumn* {...}{.importc: "ReorderColumn".}: ImGuiTableColumnIdx
  reorderColumnDir* {...}{.importc: "ReorderColumnDir".}: ImGuiTableColumnIdx
  leftMostStretchedColumn* {...}{.importc: "LeftMostStretchedColumn".}: ImGuiTableColumnIdx
  rightMostStretchedColumn* {...}{.importc: "RightMostStretchedColumn".}: ImGuiTableColumnIdx
  rightMostEnabledColumn* {...}{.importc: "RightMostEnabledColumn".}: ImGuiTableColumnIdx
  contextPopupColumn* {...}{.importc: "ContextPopupColumn".}: ImGuiTableColumnIdx
  freezeRowsRequest* {...}{.importc: "FreezeRowsRequest".}: ImGuiTableColumnIdx
  freezeRowsCount* {...}{.importc: "FreezeRowsCount".}: ImGuiTableColumnIdx
  freezeColumnsRequest* {...}{.importc: "FreezeColumnsRequest".}: ImGuiTableColumnIdx
  freezeColumnsCount* {...}{.importc: "FreezeColumnsCount".}: ImGuiTableColumnIdx
  rowCellDataCurrent* {...}{.importc: "RowCellDataCurrent".}: ImGuiTableColumnIdx
  dummyDrawChannel* {...}{.importc: "DummyDrawChannel".}: ImGuiTableDrawChannelIdx
  bg2DrawChannelCurrent* {...}{.importc: "Bg2DrawChannelCurrent".}: ImGuiTableDrawChannelIdx
  bg2DrawChannelUnfrozen* {...}{.importc: "Bg2DrawChannelUnfrozen".}: ImGuiTableDrawChannelIdx
  isLayoutLocked* {...}{.importc: "IsLayoutLocked".}: bool
  isInsideRow* {...}{.importc: "IsInsideRow".}: bool
  isInitializing* {...}{.importc: "IsInitializing".}: bool
  isSortSpecsDirty* {...}{.importc: "IsSortSpecsDirty".}: bool
  isUsingHeaders* {...}{.importc: "IsUsingHeaders".}: bool
  isContextPopupOpen* {...}{.importc: "IsContextPopupOpen".}: bool
  isSettingsRequestLoad* {...}{.importc: "IsSettingsRequestLoad".}: bool
  isSettingsDirty* {...}{.importc: "IsSettingsDirty".}: bool
  isDefaultDisplayOrder* {...}{.importc: "IsDefaultDisplayOrder".}: bool
  isResetAllRequest* {...}{.importc: "IsResetAllRequest".}: bool
  isResetDisplayOrderRequest* {...}{.importc: "IsResetDisplayOrderRequest".}: bool
  isUnfrozenRows* {...}{.importc: "IsUnfrozenRows".}: bool
  isDefaultSizingPolicy* {...}{.importc: "IsDefaultSizingPolicy".}: bool
  memoryCompacted* {...}{.importc: "MemoryCompacted".}: bool
  hostSkipItems* {...}{.importc: "HostSkipItems".}: bool
ImGuiTableCellData {...}{.importc: "ImGuiTableCellData", header: "cimgui.h".} = object
  bgColor* {...}{.importc: "BgColor".}: uint32
  column* {...}{.importc: "Column".}: ImGuiTableColumnIdx
ImGuiTableColumn {...}{.importc: "ImGuiTableColumn", header: "cimgui.h".} = object
  flags* {...}{.importc: "Flags".}: ImGuiTableColumnFlags
  widthGiven* {...}{.importc: "WidthGiven".}: float32
  minX* {...}{.importc: "MinX".}: float32
  maxX* {...}{.importc: "MaxX".}: float32
  widthRequest* {...}{.importc: "WidthRequest".}: float32
  widthAuto* {...}{.importc: "WidthAuto".}: float32
  stretchWeight* {...}{.importc: "StretchWeight".}: float32
  initStretchWeightOrWidth* {...}{.importc: "InitStretchWeightOrWidth".}: float32
  clipRect* {...}{.importc: "ClipRect".}: ImRect
  userID* {...}{.importc: "UserID".}: ImGuiID
  workMinX* {...}{.importc: "WorkMinX".}: float32
  workMaxX* {...}{.importc: "WorkMaxX".}: float32
  itemWidth* {...}{.importc: "ItemWidth".}: float32
  contentMaxXFrozen* {...}{.importc: "ContentMaxXFrozen".}: float32
  contentMaxXUnfrozen* {...}{.importc: "ContentMaxXUnfrozen".}: float32
  contentMaxXHeadersUsed* {...}{.importc: "ContentMaxXHeadersUsed".}: float32
  contentMaxXHeadersIdeal* {...}{.importc: "ContentMaxXHeadersIdeal".}: float32
  nameOffset* {...}{.importc: "NameOffset".}: int16
  displayOrder* {...}{.importc: "DisplayOrder".}: ImGuiTableColumnIdx
  indexWithinEnabledSet* {...}{.importc: "IndexWithinEnabledSet".}: ImGuiTableColumnIdx
  prevEnabledColumn* {...}{.importc: "PrevEnabledColumn".}: ImGuiTableColumnIdx
  nextEnabledColumn* {...}{.importc: "NextEnabledColumn".}: ImGuiTableColumnIdx
  sortOrder* {...}{.importc: "SortOrder".}: ImGuiTableColumnIdx
  drawChannelCurrent* {...}{.importc: "DrawChannelCurrent".}: ImGuiTableDrawChannelIdx
  drawChannelFrozen* {...}{.importc: "DrawChannelFrozen".}: ImGuiTableDrawChannelIdx
  drawChannelUnfrozen* {...}{.importc: "DrawChannelUnfrozen".}: ImGuiTableDrawChannelIdx
  isEnabled* {...}{.importc: "IsEnabled".}: bool
  isEnabledNextFrame* {...}{.importc: "IsEnabledNextFrame".}: bool
  isVisibleX* {...}{.importc: "IsVisibleX".}: bool
  isVisibleY* {...}