// Code generated by cmd/codegen from https://github.com/AllenDang/cimgui-go.
// DO NOT EDIT.

package imgui

// #include <stdlib.h>
// #include <memory.h>
// #include "wrapper.h"
// #include "typedefs.h"
// #include "../imgui/extra_types.h"
import "C"
import "github.com/AllenDang/cimgui-go/internal"

type BitArrayPtr struct {
	Data *uint32
}

// Handle returns C version of BitArrayPtr and its finalizer func.
func (self *BitArrayPtr) Handle() (*C.ImBitArrayPtr, func()) {
	result, fn := self.C()
	return &result, fn
}

// C is like Handle but returns plain type instead of pointer.
func (selfStruct *BitArrayPtr) C() (result C.ImBitArrayPtr, fin func()) {
	self := selfStruct.Data
	selfArg, selfFin := internal.WrapNumberPtr[C.ImU32, uint32](self)
	return (C.ImBitArrayPtr)(selfArg), func() { selfFin() }
}

// NewBitArrayPtrFromC creates BitArrayPtr from its C pointer.
// SRC ~= *C.ImBitArrayPtr
func NewBitArrayPtrFromC[SRC any](cvalue SRC) *BitArrayPtr {
	v := (*C.ImU32)(*internal.ReinterpretCast[*C.ImBitArrayPtr](cvalue))
	return &BitArrayPtr{Data: (*uint32)(v)}
}

type BitVector struct {
	CData *C.ImBitVector
}

// Handle returns C version of BitVector and its finalizer func.
func (self *BitVector) Handle() (result *C.ImBitVector, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self BitVector) C() (C.ImBitVector, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyBitVector creates BitVector with its 0 value.
func NewEmptyBitVector() *BitVector {
	return &BitVector{CData: new(C.ImBitVector)}
}

// NewBitVectorFromC creates BitVector from its C pointer.
// SRC ~= *C.ImBitVector
func NewBitVectorFromC[SRC any](cvalue SRC) *BitVector {
	return &BitVector{CData: internal.ReinterpretCast[*C.ImBitVector](cvalue)}
}

type DrawChannel struct {
	CData *C.ImDrawChannel
}

// Handle returns C version of DrawChannel and its finalizer func.
func (self *DrawChannel) Handle() (result *C.ImDrawChannel, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawChannel) C() (C.ImDrawChannel, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDrawChannel creates DrawChannel with its 0 value.
func NewEmptyDrawChannel() *DrawChannel {
	return &DrawChannel{CData: new(C.ImDrawChannel)}
}

// NewDrawChannelFromC creates DrawChannel from its C pointer.
// SRC ~= *C.ImDrawChannel
func NewDrawChannelFromC[SRC any](cvalue SRC) *DrawChannel {
	return &DrawChannel{CData: internal.ReinterpretCast[*C.ImDrawChannel](cvalue)}
}

type DrawCmd struct {
	CData *C.ImDrawCmd
}

// Handle returns C version of DrawCmd and its finalizer func.
func (self *DrawCmd) Handle() (result *C.ImDrawCmd, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawCmd) C() (C.ImDrawCmd, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDrawCmd creates DrawCmd with its 0 value.
func NewEmptyDrawCmd() *DrawCmd {
	return &DrawCmd{CData: new(C.ImDrawCmd)}
}

// NewDrawCmdFromC creates DrawCmd from its C pointer.
// SRC ~= *C.ImDrawCmd
func NewDrawCmdFromC[SRC any](cvalue SRC) *DrawCmd {
	return &DrawCmd{CData: internal.ReinterpretCast[*C.ImDrawCmd](cvalue)}
}

type DrawCmdHeader struct {
	CData *C.ImDrawCmdHeader
}

// Handle returns C version of DrawCmdHeader and its finalizer func.
func (self *DrawCmdHeader) Handle() (result *C.ImDrawCmdHeader, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawCmdHeader) C() (C.ImDrawCmdHeader, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDrawCmdHeader creates DrawCmdHeader with its 0 value.
func NewEmptyDrawCmdHeader() *DrawCmdHeader {
	return &DrawCmdHeader{CData: new(C.ImDrawCmdHeader)}
}

// NewDrawCmdHeaderFromC creates DrawCmdHeader from its C pointer.
// SRC ~= *C.ImDrawCmdHeader
func NewDrawCmdHeaderFromC[SRC any](cvalue SRC) *DrawCmdHeader {
	return &DrawCmdHeader{CData: internal.ReinterpretCast[*C.ImDrawCmdHeader](cvalue)}
}

type DrawData struct {
	CData *C.ImDrawData
}

// Handle returns C version of DrawData and its finalizer func.
func (self *DrawData) Handle() (result *C.ImDrawData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawData) C() (C.ImDrawData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDrawData creates DrawData with its 0 value.
func NewEmptyDrawData() *DrawData {
	return &DrawData{CData: new(C.ImDrawData)}
}

// NewDrawDataFromC creates DrawData from its C pointer.
// SRC ~= *C.ImDrawData
func NewDrawDataFromC[SRC any](cvalue SRC) *DrawData {
	return &DrawData{CData: internal.ReinterpretCast[*C.ImDrawData](cvalue)}
}

type DrawDataBuilder struct {
	CData *C.ImDrawDataBuilder
}

// Handle returns C version of DrawDataBuilder and its finalizer func.
func (self *DrawDataBuilder) Handle() (result *C.ImDrawDataBuilder, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawDataBuilder) C() (C.ImDrawDataBuilder, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDrawDataBuilder creates DrawDataBuilder with its 0 value.
func NewEmptyDrawDataBuilder() *DrawDataBuilder {
	return &DrawDataBuilder{CData: new(C.ImDrawDataBuilder)}
}

// NewDrawDataBuilderFromC creates DrawDataBuilder from its C pointer.
// SRC ~= *C.ImDrawDataBuilder
func NewDrawDataBuilderFromC[SRC any](cvalue SRC) *DrawDataBuilder {
	return &DrawDataBuilder{CData: internal.ReinterpretCast[*C.ImDrawDataBuilder](cvalue)}
}

type DrawIdx uint16

// Handle returns C version of DrawIdx and its finalizer func.
func (selfSrc *DrawIdx) Handle() (result *C.ImDrawIdx, fin func()) {
	self := (*uint16)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.ushort, uint16](self)
	return (*C.ImDrawIdx)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawIdx) C() (C.ImDrawIdx, func()) {
	return (C.ImDrawIdx)(C.ushort(self)), func() {}
}

// NewDrawIdxFromC creates DrawIdx from its C pointer.
// SRC ~= *C.ImDrawIdx
func NewDrawIdxFromC[SRC any](cvalue SRC) *DrawIdx {
	return (*DrawIdx)((*uint16)(internal.ReinterpretCast[*C.ImDrawIdx](cvalue)))
}

type DrawList struct {
	CData *C.ImDrawList
}

// Handle returns C version of DrawList and its finalizer func.
func (self *DrawList) Handle() (result *C.ImDrawList, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawList) C() (C.ImDrawList, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDrawList creates DrawList with its 0 value.
func NewEmptyDrawList() *DrawList {
	return &DrawList{CData: new(C.ImDrawList)}
}

// NewDrawListFromC creates DrawList from its C pointer.
// SRC ~= *C.ImDrawList
func NewDrawListFromC[SRC any](cvalue SRC) *DrawList {
	return &DrawList{CData: internal.ReinterpretCast[*C.ImDrawList](cvalue)}
}

type DrawListSharedData struct {
	CData *C.ImDrawListSharedData
}

// Handle returns C version of DrawListSharedData and its finalizer func.
func (self *DrawListSharedData) Handle() (result *C.ImDrawListSharedData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawListSharedData) C() (C.ImDrawListSharedData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDrawListSharedData creates DrawListSharedData with its 0 value.
func NewEmptyDrawListSharedData() *DrawListSharedData {
	return &DrawListSharedData{CData: new(C.ImDrawListSharedData)}
}

// NewDrawListSharedDataFromC creates DrawListSharedData from its C pointer.
// SRC ~= *C.ImDrawListSharedData
func NewDrawListSharedDataFromC[SRC any](cvalue SRC) *DrawListSharedData {
	return &DrawListSharedData{CData: internal.ReinterpretCast[*C.ImDrawListSharedData](cvalue)}
}

type DrawListSplitter struct {
	CData *C.ImDrawListSplitter
}

// Handle returns C version of DrawListSplitter and its finalizer func.
func (self *DrawListSplitter) Handle() (result *C.ImDrawListSplitter, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawListSplitter) C() (C.ImDrawListSplitter, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDrawListSplitter creates DrawListSplitter with its 0 value.
func NewEmptyDrawListSplitter() *DrawListSplitter {
	return &DrawListSplitter{CData: new(C.ImDrawListSplitter)}
}

// NewDrawListSplitterFromC creates DrawListSplitter from its C pointer.
// SRC ~= *C.ImDrawListSplitter
func NewDrawListSplitterFromC[SRC any](cvalue SRC) *DrawListSplitter {
	return &DrawListSplitter{CData: internal.ReinterpretCast[*C.ImDrawListSplitter](cvalue)}
}

type DrawVert struct {
	CData *C.ImDrawVert
}

// Handle returns C version of DrawVert and its finalizer func.
func (self *DrawVert) Handle() (result *C.ImDrawVert, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DrawVert) C() (C.ImDrawVert, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDrawVert creates DrawVert with its 0 value.
func NewEmptyDrawVert() *DrawVert {
	return &DrawVert{CData: new(C.ImDrawVert)}
}

// NewDrawVertFromC creates DrawVert from its C pointer.
// SRC ~= *C.ImDrawVert
func NewDrawVertFromC[SRC any](cvalue SRC) *DrawVert {
	return &DrawVert{CData: internal.ReinterpretCast[*C.ImDrawVert](cvalue)}
}

type Font struct {
	CData *C.ImFont
}

// Handle returns C version of Font and its finalizer func.
func (self *Font) Handle() (result *C.ImFont, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Font) C() (C.ImFont, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFont creates Font with its 0 value.
func NewEmptyFont() *Font {
	return &Font{CData: new(C.ImFont)}
}

// NewFontFromC creates Font from its C pointer.
// SRC ~= *C.ImFont
func NewFontFromC[SRC any](cvalue SRC) *Font {
	return &Font{CData: internal.ReinterpretCast[*C.ImFont](cvalue)}
}

type FontAtlas struct {
	CData *C.ImFontAtlas
}

// Handle returns C version of FontAtlas and its finalizer func.
func (self *FontAtlas) Handle() (result *C.ImFontAtlas, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontAtlas) C() (C.ImFontAtlas, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontAtlas creates FontAtlas with its 0 value.
func NewEmptyFontAtlas() *FontAtlas {
	return &FontAtlas{CData: new(C.ImFontAtlas)}
}

// NewFontAtlasFromC creates FontAtlas from its C pointer.
// SRC ~= *C.ImFontAtlas
func NewFontAtlasFromC[SRC any](cvalue SRC) *FontAtlas {
	return &FontAtlas{CData: internal.ReinterpretCast[*C.ImFontAtlas](cvalue)}
}

type FontAtlasBuilder struct {
	CData *C.ImFontAtlasBuilder
}

// Handle returns C version of FontAtlasBuilder and its finalizer func.
func (self *FontAtlasBuilder) Handle() (result *C.ImFontAtlasBuilder, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontAtlasBuilder) C() (C.ImFontAtlasBuilder, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontAtlasBuilder creates FontAtlasBuilder with its 0 value.
func NewEmptyFontAtlasBuilder() *FontAtlasBuilder {
	return &FontAtlasBuilder{CData: new(C.ImFontAtlasBuilder)}
}

// NewFontAtlasBuilderFromC creates FontAtlasBuilder from its C pointer.
// SRC ~= *C.ImFontAtlasBuilder
func NewFontAtlasBuilderFromC[SRC any](cvalue SRC) *FontAtlasBuilder {
	return &FontAtlasBuilder{CData: internal.ReinterpretCast[*C.ImFontAtlasBuilder](cvalue)}
}

type FontAtlasPostProcessData struct {
	CData *C.ImFontAtlasPostProcessData
}

// Handle returns C version of FontAtlasPostProcessData and its finalizer func.
func (self *FontAtlasPostProcessData) Handle() (result *C.ImFontAtlasPostProcessData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontAtlasPostProcessData) C() (C.ImFontAtlasPostProcessData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontAtlasPostProcessData creates FontAtlasPostProcessData with its 0 value.
func NewEmptyFontAtlasPostProcessData() *FontAtlasPostProcessData {
	return &FontAtlasPostProcessData{CData: new(C.ImFontAtlasPostProcessData)}
}

// NewFontAtlasPostProcessDataFromC creates FontAtlasPostProcessData from its C pointer.
// SRC ~= *C.ImFontAtlasPostProcessData
func NewFontAtlasPostProcessDataFromC[SRC any](cvalue SRC) *FontAtlasPostProcessData {
	return &FontAtlasPostProcessData{CData: internal.ReinterpretCast[*C.ImFontAtlasPostProcessData](cvalue)}
}

type FontAtlasRect struct {
	CData *C.ImFontAtlasRect
}

// Handle returns C version of FontAtlasRect and its finalizer func.
func (self *FontAtlasRect) Handle() (result *C.ImFontAtlasRect, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontAtlasRect) C() (C.ImFontAtlasRect, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontAtlasRect creates FontAtlasRect with its 0 value.
func NewEmptyFontAtlasRect() *FontAtlasRect {
	return &FontAtlasRect{CData: new(C.ImFontAtlasRect)}
}

// NewFontAtlasRectFromC creates FontAtlasRect from its C pointer.
// SRC ~= *C.ImFontAtlasRect
func NewFontAtlasRectFromC[SRC any](cvalue SRC) *FontAtlasRect {
	return &FontAtlasRect{CData: internal.ReinterpretCast[*C.ImFontAtlasRect](cvalue)}
}

type FontAtlasRectEntry struct {
	CData *C.ImFontAtlasRectEntry
}

// Handle returns C version of FontAtlasRectEntry and its finalizer func.
func (self *FontAtlasRectEntry) Handle() (result *C.ImFontAtlasRectEntry, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontAtlasRectEntry) C() (C.ImFontAtlasRectEntry, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontAtlasRectEntry creates FontAtlasRectEntry with its 0 value.
func NewEmptyFontAtlasRectEntry() *FontAtlasRectEntry {
	return &FontAtlasRectEntry{CData: new(C.ImFontAtlasRectEntry)}
}

// NewFontAtlasRectEntryFromC creates FontAtlasRectEntry from its C pointer.
// SRC ~= *C.ImFontAtlasRectEntry
func NewFontAtlasRectEntryFromC[SRC any](cvalue SRC) *FontAtlasRectEntry {
	return &FontAtlasRectEntry{CData: internal.ReinterpretCast[*C.ImFontAtlasRectEntry](cvalue)}
}

type FontAtlasRectId int32

// Handle returns C version of FontAtlasRectId and its finalizer func.
func (selfSrc *FontAtlasRectId) Handle() (result *C.ImFontAtlasRectId, fin func()) {
	self := (*int32)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.int, int32](self)
	return (*C.ImFontAtlasRectId)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self FontAtlasRectId) C() (C.ImFontAtlasRectId, func()) {
	return (C.ImFontAtlasRectId)(C.int(self)), func() {}
}

// NewFontAtlasRectIdFromC creates FontAtlasRectId from its C pointer.
// SRC ~= *C.ImFontAtlasRectId
func NewFontAtlasRectIdFromC[SRC any](cvalue SRC) *FontAtlasRectId {
	return (*FontAtlasRectId)((*int32)(internal.ReinterpretCast[*C.ImFontAtlasRectId](cvalue)))
}

type FontBaked struct {
	CData *C.ImFontBaked
}

// Handle returns C version of FontBaked and its finalizer func.
func (self *FontBaked) Handle() (result *C.ImFontBaked, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontBaked) C() (C.ImFontBaked, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontBaked creates FontBaked with its 0 value.
func NewEmptyFontBaked() *FontBaked {
	return &FontBaked{CData: new(C.ImFontBaked)}
}

// NewFontBakedFromC creates FontBaked from its C pointer.
// SRC ~= *C.ImFontBaked
func NewFontBakedFromC[SRC any](cvalue SRC) *FontBaked {
	return &FontBaked{CData: internal.ReinterpretCast[*C.ImFontBaked](cvalue)}
}

type FontConfig struct {
	CData *C.ImFontConfig
}

// Handle returns C version of FontConfig and its finalizer func.
func (self *FontConfig) Handle() (result *C.ImFontConfig, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontConfig) C() (C.ImFontConfig, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontConfig creates FontConfig with its 0 value.
func NewEmptyFontConfig() *FontConfig {
	return &FontConfig{CData: new(C.ImFontConfig)}
}

// NewFontConfigFromC creates FontConfig from its C pointer.
// SRC ~= *C.ImFontConfig
func NewFontConfigFromC[SRC any](cvalue SRC) *FontConfig {
	return &FontConfig{CData: internal.ReinterpretCast[*C.ImFontConfig](cvalue)}
}

type FontGlyph struct {
	CData *C.ImFontGlyph
}

// Handle returns C version of FontGlyph and its finalizer func.
func (self *FontGlyph) Handle() (result *C.ImFontGlyph, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontGlyph) C() (C.ImFontGlyph, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontGlyph creates FontGlyph with its 0 value.
func NewEmptyFontGlyph() *FontGlyph {
	return &FontGlyph{CData: new(C.ImFontGlyph)}
}

// NewFontGlyphFromC creates FontGlyph from its C pointer.
// SRC ~= *C.ImFontGlyph
func NewFontGlyphFromC[SRC any](cvalue SRC) *FontGlyph {
	return &FontGlyph{CData: internal.ReinterpretCast[*C.ImFontGlyph](cvalue)}
}

type FontGlyphRangesBuilder struct {
	CData *C.ImFontGlyphRangesBuilder
}

// Handle returns C version of FontGlyphRangesBuilder and its finalizer func.
func (self *FontGlyphRangesBuilder) Handle() (result *C.ImFontGlyphRangesBuilder, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontGlyphRangesBuilder) C() (C.ImFontGlyphRangesBuilder, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontGlyphRangesBuilder creates FontGlyphRangesBuilder with its 0 value.
func NewEmptyFontGlyphRangesBuilder() *FontGlyphRangesBuilder {
	return &FontGlyphRangesBuilder{CData: new(C.ImFontGlyphRangesBuilder)}
}

// NewFontGlyphRangesBuilderFromC creates FontGlyphRangesBuilder from its C pointer.
// SRC ~= *C.ImFontGlyphRangesBuilder
func NewFontGlyphRangesBuilderFromC[SRC any](cvalue SRC) *FontGlyphRangesBuilder {
	return &FontGlyphRangesBuilder{CData: internal.ReinterpretCast[*C.ImFontGlyphRangesBuilder](cvalue)}
}

type FontLoader struct {
	CData *C.ImFontLoader
}

// Handle returns C version of FontLoader and its finalizer func.
func (self *FontLoader) Handle() (result *C.ImFontLoader, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontLoader) C() (C.ImFontLoader, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontLoader creates FontLoader with its 0 value.
func NewEmptyFontLoader() *FontLoader {
	return &FontLoader{CData: new(C.ImFontLoader)}
}

// NewFontLoaderFromC creates FontLoader from its C pointer.
// SRC ~= *C.ImFontLoader
func NewFontLoaderFromC[SRC any](cvalue SRC) *FontLoader {
	return &FontLoader{CData: internal.ReinterpretCast[*C.ImFontLoader](cvalue)}
}

type FontStackData struct {
	CData *C.ImFontStackData
}

// Handle returns C version of FontStackData and its finalizer func.
func (self *FontStackData) Handle() (result *C.ImFontStackData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FontStackData) C() (C.ImFontStackData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFontStackData creates FontStackData with its 0 value.
func NewEmptyFontStackData() *FontStackData {
	return &FontStackData{CData: new(C.ImFontStackData)}
}

// NewFontStackDataFromC creates FontStackData from its C pointer.
// SRC ~= *C.ImFontStackData
func NewFontStackDataFromC[SRC any](cvalue SRC) *FontStackData {
	return &FontStackData{CData: internal.ReinterpretCast[*C.ImFontStackData](cvalue)}
}

type BoxSelectState struct {
	CData *C.ImGuiBoxSelectState
}

// Handle returns C version of BoxSelectState and its finalizer func.
func (self *BoxSelectState) Handle() (result *C.ImGuiBoxSelectState, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self BoxSelectState) C() (C.ImGuiBoxSelectState, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyBoxSelectState creates BoxSelectState with its 0 value.
func NewEmptyBoxSelectState() *BoxSelectState {
	return &BoxSelectState{CData: new(C.ImGuiBoxSelectState)}
}

// NewBoxSelectStateFromC creates BoxSelectState from its C pointer.
// SRC ~= *C.ImGuiBoxSelectState
func NewBoxSelectStateFromC[SRC any](cvalue SRC) *BoxSelectState {
	return &BoxSelectState{CData: internal.ReinterpretCast[*C.ImGuiBoxSelectState](cvalue)}
}

type ColorMod struct {
	CData *C.ImGuiColorMod
}

// Handle returns C version of ColorMod and its finalizer func.
func (self *ColorMod) Handle() (result *C.ImGuiColorMod, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self ColorMod) C() (C.ImGuiColorMod, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyColorMod creates ColorMod with its 0 value.
func NewEmptyColorMod() *ColorMod {
	return &ColorMod{CData: new(C.ImGuiColorMod)}
}

// NewColorModFromC creates ColorMod from its C pointer.
// SRC ~= *C.ImGuiColorMod
func NewColorModFromC[SRC any](cvalue SRC) *ColorMod {
	return &ColorMod{CData: internal.ReinterpretCast[*C.ImGuiColorMod](cvalue)}
}

type ComboPreviewData struct {
	CData *C.ImGuiComboPreviewData
}

// Handle returns C version of ComboPreviewData and its finalizer func.
func (self *ComboPreviewData) Handle() (result *C.ImGuiComboPreviewData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self ComboPreviewData) C() (C.ImGuiComboPreviewData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyComboPreviewData creates ComboPreviewData with its 0 value.
func NewEmptyComboPreviewData() *ComboPreviewData {
	return &ComboPreviewData{CData: new(C.ImGuiComboPreviewData)}
}

// NewComboPreviewDataFromC creates ComboPreviewData from its C pointer.
// SRC ~= *C.ImGuiComboPreviewData
func NewComboPreviewDataFromC[SRC any](cvalue SRC) *ComboPreviewData {
	return &ComboPreviewData{CData: internal.ReinterpretCast[*C.ImGuiComboPreviewData](cvalue)}
}

type Context struct {
	CData *C.ImGuiContext
}

// Handle returns C version of Context and its finalizer func.
func (self *Context) Handle() (result *C.ImGuiContext, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Context) C() (C.ImGuiContext, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyContext creates Context with its 0 value.
func NewEmptyContext() *Context {
	return &Context{CData: new(C.ImGuiContext)}
}

// NewContextFromC creates Context from its C pointer.
// SRC ~= *C.ImGuiContext
func NewContextFromC[SRC any](cvalue SRC) *Context {
	return &Context{CData: internal.ReinterpretCast[*C.ImGuiContext](cvalue)}
}

type ContextHook struct {
	CData *C.ImGuiContextHook
}

// Handle returns C version of ContextHook and its finalizer func.
func (self *ContextHook) Handle() (result *C.ImGuiContextHook, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self ContextHook) C() (C.ImGuiContextHook, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyContextHook creates ContextHook with its 0 value.
func NewEmptyContextHook() *ContextHook {
	return &ContextHook{CData: new(C.ImGuiContextHook)}
}

// NewContextHookFromC creates ContextHook from its C pointer.
// SRC ~= *C.ImGuiContextHook
func NewContextHookFromC[SRC any](cvalue SRC) *ContextHook {
	return &ContextHook{CData: internal.ReinterpretCast[*C.ImGuiContextHook](cvalue)}
}

type DataTypeInfo struct {
	CData *C.ImGuiDataTypeInfo
}

// Handle returns C version of DataTypeInfo and its finalizer func.
func (self *DataTypeInfo) Handle() (result *C.ImGuiDataTypeInfo, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DataTypeInfo) C() (C.ImGuiDataTypeInfo, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDataTypeInfo creates DataTypeInfo with its 0 value.
func NewEmptyDataTypeInfo() *DataTypeInfo {
	return &DataTypeInfo{CData: new(C.ImGuiDataTypeInfo)}
}

// NewDataTypeInfoFromC creates DataTypeInfo from its C pointer.
// SRC ~= *C.ImGuiDataTypeInfo
func NewDataTypeInfoFromC[SRC any](cvalue SRC) *DataTypeInfo {
	return &DataTypeInfo{CData: internal.ReinterpretCast[*C.ImGuiDataTypeInfo](cvalue)}
}

type DataTypeStorage struct {
	CData *C.ImGuiDataTypeStorage
}

// Handle returns C version of DataTypeStorage and its finalizer func.
func (self *DataTypeStorage) Handle() (result *C.ImGuiDataTypeStorage, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DataTypeStorage) C() (C.ImGuiDataTypeStorage, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDataTypeStorage creates DataTypeStorage with its 0 value.
func NewEmptyDataTypeStorage() *DataTypeStorage {
	return &DataTypeStorage{CData: new(C.ImGuiDataTypeStorage)}
}

// NewDataTypeStorageFromC creates DataTypeStorage from its C pointer.
// SRC ~= *C.ImGuiDataTypeStorage
func NewDataTypeStorageFromC[SRC any](cvalue SRC) *DataTypeStorage {
	return &DataTypeStorage{CData: internal.ReinterpretCast[*C.ImGuiDataTypeStorage](cvalue)}
}

type DeactivatedItemData struct {
	CData *C.ImGuiDeactivatedItemData
}

// Handle returns C version of DeactivatedItemData and its finalizer func.
func (self *DeactivatedItemData) Handle() (result *C.ImGuiDeactivatedItemData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DeactivatedItemData) C() (C.ImGuiDeactivatedItemData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDeactivatedItemData creates DeactivatedItemData with its 0 value.
func NewEmptyDeactivatedItemData() *DeactivatedItemData {
	return &DeactivatedItemData{CData: new(C.ImGuiDeactivatedItemData)}
}

// NewDeactivatedItemDataFromC creates DeactivatedItemData from its C pointer.
// SRC ~= *C.ImGuiDeactivatedItemData
func NewDeactivatedItemDataFromC[SRC any](cvalue SRC) *DeactivatedItemData {
	return &DeactivatedItemData{CData: internal.ReinterpretCast[*C.ImGuiDeactivatedItemData](cvalue)}
}

type DebugAllocEntry struct {
	CData *C.ImGuiDebugAllocEntry
}

// Handle returns C version of DebugAllocEntry and its finalizer func.
func (self *DebugAllocEntry) Handle() (result *C.ImGuiDebugAllocEntry, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DebugAllocEntry) C() (C.ImGuiDebugAllocEntry, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDebugAllocEntry creates DebugAllocEntry with its 0 value.
func NewEmptyDebugAllocEntry() *DebugAllocEntry {
	return &DebugAllocEntry{CData: new(C.ImGuiDebugAllocEntry)}
}

// NewDebugAllocEntryFromC creates DebugAllocEntry from its C pointer.
// SRC ~= *C.ImGuiDebugAllocEntry
func NewDebugAllocEntryFromC[SRC any](cvalue SRC) *DebugAllocEntry {
	return &DebugAllocEntry{CData: internal.ReinterpretCast[*C.ImGuiDebugAllocEntry](cvalue)}
}

type DebugAllocInfo struct {
	CData *C.ImGuiDebugAllocInfo
}

// Handle returns C version of DebugAllocInfo and its finalizer func.
func (self *DebugAllocInfo) Handle() (result *C.ImGuiDebugAllocInfo, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DebugAllocInfo) C() (C.ImGuiDebugAllocInfo, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDebugAllocInfo creates DebugAllocInfo with its 0 value.
func NewEmptyDebugAllocInfo() *DebugAllocInfo {
	return &DebugAllocInfo{CData: new(C.ImGuiDebugAllocInfo)}
}

// NewDebugAllocInfoFromC creates DebugAllocInfo from its C pointer.
// SRC ~= *C.ImGuiDebugAllocInfo
func NewDebugAllocInfoFromC[SRC any](cvalue SRC) *DebugAllocInfo {
	return &DebugAllocInfo{CData: internal.ReinterpretCast[*C.ImGuiDebugAllocInfo](cvalue)}
}

type DockContext struct {
	CData *C.ImGuiDockContext
}

// Handle returns C version of DockContext and its finalizer func.
func (self *DockContext) Handle() (result *C.ImGuiDockContext, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DockContext) C() (C.ImGuiDockContext, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDockContext creates DockContext with its 0 value.
func NewEmptyDockContext() *DockContext {
	return &DockContext{CData: new(C.ImGuiDockContext)}
}

// NewDockContextFromC creates DockContext from its C pointer.
// SRC ~= *C.ImGuiDockContext
func NewDockContextFromC[SRC any](cvalue SRC) *DockContext {
	return &DockContext{CData: internal.ReinterpretCast[*C.ImGuiDockContext](cvalue)}
}

type DockNode struct {
	CData *C.ImGuiDockNode
}

// Handle returns C version of DockNode and its finalizer func.
func (self *DockNode) Handle() (result *C.ImGuiDockNode, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self DockNode) C() (C.ImGuiDockNode, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyDockNode creates DockNode with its 0 value.
func NewEmptyDockNode() *DockNode {
	return &DockNode{CData: new(C.ImGuiDockNode)}
}

// NewDockNodeFromC creates DockNode from its C pointer.
// SRC ~= *C.ImGuiDockNode
func NewDockNodeFromC[SRC any](cvalue SRC) *DockNode {
	return &DockNode{CData: internal.ReinterpretCast[*C.ImGuiDockNode](cvalue)}
}

type DockNodeSettings struct {
	CData *C.ImGuiDockNodeSettings
}

// Handle returns C version of DockNodeSettings and its finalizer func.
func (self *DockNodeSettings) Handle() (result *C.ImGuiDockNodeSettings, fin func()) {
	return self.CData, func() {}
}

// NewDockNodeSettingsFromC creates DockNodeSettings from its C pointer.
// SRC ~= *C.ImGuiDockNodeSettings
func NewDockNodeSettingsFromC[SRC any](cvalue SRC) *DockNodeSettings {
	return &DockNodeSettings{CData: internal.ReinterpretCast[*C.ImGuiDockNodeSettings](cvalue)}
}

type DockRequest struct {
	CData *C.ImGuiDockRequest
}

// Handle returns C version of DockRequest and its finalizer func.
func (self *DockRequest) Handle() (result *C.ImGuiDockRequest, fin func()) {
	return self.CData, func() {}
}

// NewDockRequestFromC creates DockRequest from its C pointer.
// SRC ~= *C.ImGuiDockRequest
func NewDockRequestFromC[SRC any](cvalue SRC) *DockRequest {
	return &DockRequest{CData: internal.ReinterpretCast[*C.ImGuiDockRequest](cvalue)}
}

type ErrorRecoveryState struct {
	CData *C.ImGuiErrorRecoveryState
}

// Handle returns C version of ErrorRecoveryState and its finalizer func.
func (self *ErrorRecoveryState) Handle() (result *C.ImGuiErrorRecoveryState, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self ErrorRecoveryState) C() (C.ImGuiErrorRecoveryState, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyErrorRecoveryState creates ErrorRecoveryState with its 0 value.
func NewEmptyErrorRecoveryState() *ErrorRecoveryState {
	return &ErrorRecoveryState{CData: new(C.ImGuiErrorRecoveryState)}
}

// NewErrorRecoveryStateFromC creates ErrorRecoveryState from its C pointer.
// SRC ~= *C.ImGuiErrorRecoveryState
func NewErrorRecoveryStateFromC[SRC any](cvalue SRC) *ErrorRecoveryState {
	return &ErrorRecoveryState{CData: internal.ReinterpretCast[*C.ImGuiErrorRecoveryState](cvalue)}
}

type FocusScopeData struct {
	CData *C.ImGuiFocusScopeData
}

// Handle returns C version of FocusScopeData and its finalizer func.
func (self *FocusScopeData) Handle() (result *C.ImGuiFocusScopeData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self FocusScopeData) C() (C.ImGuiFocusScopeData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyFocusScopeData creates FocusScopeData with its 0 value.
func NewEmptyFocusScopeData() *FocusScopeData {
	return &FocusScopeData{CData: new(C.ImGuiFocusScopeData)}
}

// NewFocusScopeDataFromC creates FocusScopeData from its C pointer.
// SRC ~= *C.ImGuiFocusScopeData
func NewFocusScopeDataFromC[SRC any](cvalue SRC) *FocusScopeData {
	return &FocusScopeData{CData: internal.ReinterpretCast[*C.ImGuiFocusScopeData](cvalue)}
}

type GroupData struct {
	CData *C.ImGuiGroupData
}

// Handle returns C version of GroupData and its finalizer func.
func (self *GroupData) Handle() (result *C.ImGuiGroupData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self GroupData) C() (C.ImGuiGroupData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyGroupData creates GroupData with its 0 value.
func NewEmptyGroupData() *GroupData {
	return &GroupData{CData: new(C.ImGuiGroupData)}
}

// NewGroupDataFromC creates GroupData from its C pointer.
// SRC ~= *C.ImGuiGroupData
func NewGroupDataFromC[SRC any](cvalue SRC) *GroupData {
	return &GroupData{CData: internal.ReinterpretCast[*C.ImGuiGroupData](cvalue)}
}

type ID uint32

// Handle returns C version of ID and its finalizer func.
func (selfSrc *ID) Handle() (result *C.ImGuiID, fin func()) {
	self := (*uint32)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.uint, uint32](self)
	return (*C.ImGuiID)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self ID) C() (C.ImGuiID, func()) {
	return (C.ImGuiID)(C.uint(self)), func() {}
}

// NewIDFromC creates ID from its C pointer.
// SRC ~= *C.ImGuiID
func NewIDFromC[SRC any](cvalue SRC) *ID {
	return (*ID)((*uint32)(internal.ReinterpretCast[*C.ImGuiID](cvalue)))
}

type IDStackTool struct {
	CData *C.ImGuiIDStackTool
}

// Handle returns C version of IDStackTool and its finalizer func.
func (self *IDStackTool) Handle() (result *C.ImGuiIDStackTool, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self IDStackTool) C() (C.ImGuiIDStackTool, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyIDStackTool creates IDStackTool with its 0 value.
func NewEmptyIDStackTool() *IDStackTool {
	return &IDStackTool{CData: new(C.ImGuiIDStackTool)}
}

// NewIDStackToolFromC creates IDStackTool from its C pointer.
// SRC ~= *C.ImGuiIDStackTool
func NewIDStackToolFromC[SRC any](cvalue SRC) *IDStackTool {
	return &IDStackTool{CData: internal.ReinterpretCast[*C.ImGuiIDStackTool](cvalue)}
}

type IO struct {
	CData *C.ImGuiIO
}

// Handle returns C version of IO and its finalizer func.
func (self *IO) Handle() (result *C.ImGuiIO, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self IO) C() (C.ImGuiIO, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyIO creates IO with its 0 value.
func NewEmptyIO() *IO {
	return &IO{CData: new(C.ImGuiIO)}
}

// NewIOFromC creates IO from its C pointer.
// SRC ~= *C.ImGuiIO
func NewIOFromC[SRC any](cvalue SRC) *IO {
	return &IO{CData: internal.ReinterpretCast[*C.ImGuiIO](cvalue)}
}

type InputEvent struct {
	CData *C.ImGuiInputEvent
}

// Handle returns C version of InputEvent and its finalizer func.
func (self *InputEvent) Handle() (result *C.ImGuiInputEvent, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputEvent) C() (C.ImGuiInputEvent, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputEvent creates InputEvent with its 0 value.
func NewEmptyInputEvent() *InputEvent {
	return &InputEvent{CData: new(C.ImGuiInputEvent)}
}

// NewInputEventFromC creates InputEvent from its C pointer.
// SRC ~= *C.ImGuiInputEvent
func NewInputEventFromC[SRC any](cvalue SRC) *InputEvent {
	return &InputEvent{CData: internal.ReinterpretCast[*C.ImGuiInputEvent](cvalue)}
}

type InputEventAppFocused struct {
	CData *C.ImGuiInputEventAppFocused
}

// Handle returns C version of InputEventAppFocused and its finalizer func.
func (self *InputEventAppFocused) Handle() (result *C.ImGuiInputEventAppFocused, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputEventAppFocused) C() (C.ImGuiInputEventAppFocused, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputEventAppFocused creates InputEventAppFocused with its 0 value.
func NewEmptyInputEventAppFocused() *InputEventAppFocused {
	return &InputEventAppFocused{CData: new(C.ImGuiInputEventAppFocused)}
}

// NewInputEventAppFocusedFromC creates InputEventAppFocused from its C pointer.
// SRC ~= *C.ImGuiInputEventAppFocused
func NewInputEventAppFocusedFromC[SRC any](cvalue SRC) *InputEventAppFocused {
	return &InputEventAppFocused{CData: internal.ReinterpretCast[*C.ImGuiInputEventAppFocused](cvalue)}
}

type InputEventKey struct {
	CData *C.ImGuiInputEventKey
}

// Handle returns C version of InputEventKey and its finalizer func.
func (self *InputEventKey) Handle() (result *C.ImGuiInputEventKey, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputEventKey) C() (C.ImGuiInputEventKey, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputEventKey creates InputEventKey with its 0 value.
func NewEmptyInputEventKey() *InputEventKey {
	return &InputEventKey{CData: new(C.ImGuiInputEventKey)}
}

// NewInputEventKeyFromC creates InputEventKey from its C pointer.
// SRC ~= *C.ImGuiInputEventKey
func NewInputEventKeyFromC[SRC any](cvalue SRC) *InputEventKey {
	return &InputEventKey{CData: internal.ReinterpretCast[*C.ImGuiInputEventKey](cvalue)}
}

type InputEventMouseButton struct {
	CData *C.ImGuiInputEventMouseButton
}

// Handle returns C version of InputEventMouseButton and its finalizer func.
func (self *InputEventMouseButton) Handle() (result *C.ImGuiInputEventMouseButton, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputEventMouseButton) C() (C.ImGuiInputEventMouseButton, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputEventMouseButton creates InputEventMouseButton with its 0 value.
func NewEmptyInputEventMouseButton() *InputEventMouseButton {
	return &InputEventMouseButton{CData: new(C.ImGuiInputEventMouseButton)}
}

// NewInputEventMouseButtonFromC creates InputEventMouseButton from its C pointer.
// SRC ~= *C.ImGuiInputEventMouseButton
func NewInputEventMouseButtonFromC[SRC any](cvalue SRC) *InputEventMouseButton {
	return &InputEventMouseButton{CData: internal.ReinterpretCast[*C.ImGuiInputEventMouseButton](cvalue)}
}

type InputEventMousePos struct {
	CData *C.ImGuiInputEventMousePos
}

// Handle returns C version of InputEventMousePos and its finalizer func.
func (self *InputEventMousePos) Handle() (result *C.ImGuiInputEventMousePos, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputEventMousePos) C() (C.ImGuiInputEventMousePos, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputEventMousePos creates InputEventMousePos with its 0 value.
func NewEmptyInputEventMousePos() *InputEventMousePos {
	return &InputEventMousePos{CData: new(C.ImGuiInputEventMousePos)}
}

// NewInputEventMousePosFromC creates InputEventMousePos from its C pointer.
// SRC ~= *C.ImGuiInputEventMousePos
func NewInputEventMousePosFromC[SRC any](cvalue SRC) *InputEventMousePos {
	return &InputEventMousePos{CData: internal.ReinterpretCast[*C.ImGuiInputEventMousePos](cvalue)}
}

type InputEventMouseViewport struct {
	CData *C.ImGuiInputEventMouseViewport
}

// Handle returns C version of InputEventMouseViewport and its finalizer func.
func (self *InputEventMouseViewport) Handle() (result *C.ImGuiInputEventMouseViewport, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputEventMouseViewport) C() (C.ImGuiInputEventMouseViewport, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputEventMouseViewport creates InputEventMouseViewport with its 0 value.
func NewEmptyInputEventMouseViewport() *InputEventMouseViewport {
	return &InputEventMouseViewport{CData: new(C.ImGuiInputEventMouseViewport)}
}

// NewInputEventMouseViewportFromC creates InputEventMouseViewport from its C pointer.
// SRC ~= *C.ImGuiInputEventMouseViewport
func NewInputEventMouseViewportFromC[SRC any](cvalue SRC) *InputEventMouseViewport {
	return &InputEventMouseViewport{CData: internal.ReinterpretCast[*C.ImGuiInputEventMouseViewport](cvalue)}
}

type InputEventMouseWheel struct {
	CData *C.ImGuiInputEventMouseWheel
}

// Handle returns C version of InputEventMouseWheel and its finalizer func.
func (self *InputEventMouseWheel) Handle() (result *C.ImGuiInputEventMouseWheel, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputEventMouseWheel) C() (C.ImGuiInputEventMouseWheel, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputEventMouseWheel creates InputEventMouseWheel with its 0 value.
func NewEmptyInputEventMouseWheel() *InputEventMouseWheel {
	return &InputEventMouseWheel{CData: new(C.ImGuiInputEventMouseWheel)}
}

// NewInputEventMouseWheelFromC creates InputEventMouseWheel from its C pointer.
// SRC ~= *C.ImGuiInputEventMouseWheel
func NewInputEventMouseWheelFromC[SRC any](cvalue SRC) *InputEventMouseWheel {
	return &InputEventMouseWheel{CData: internal.ReinterpretCast[*C.ImGuiInputEventMouseWheel](cvalue)}
}

type InputEventText struct {
	CData *C.ImGuiInputEventText
}

// Handle returns C version of InputEventText and its finalizer func.
func (self *InputEventText) Handle() (result *C.ImGuiInputEventText, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputEventText) C() (C.ImGuiInputEventText, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputEventText creates InputEventText with its 0 value.
func NewEmptyInputEventText() *InputEventText {
	return &InputEventText{CData: new(C.ImGuiInputEventText)}
}

// NewInputEventTextFromC creates InputEventText from its C pointer.
// SRC ~= *C.ImGuiInputEventText
func NewInputEventTextFromC[SRC any](cvalue SRC) *InputEventText {
	return &InputEventText{CData: internal.ReinterpretCast[*C.ImGuiInputEventText](cvalue)}
}

type InputTextCallbackData struct {
	CData *C.ImGuiInputTextCallbackData
}

// Handle returns C version of InputTextCallbackData and its finalizer func.
func (self *InputTextCallbackData) Handle() (result *C.ImGuiInputTextCallbackData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputTextCallbackData) C() (C.ImGuiInputTextCallbackData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputTextCallbackData creates InputTextCallbackData with its 0 value.
func NewEmptyInputTextCallbackData() *InputTextCallbackData {
	return &InputTextCallbackData{CData: new(C.ImGuiInputTextCallbackData)}
}

// NewInputTextCallbackDataFromC creates InputTextCallbackData from its C pointer.
// SRC ~= *C.ImGuiInputTextCallbackData
func NewInputTextCallbackDataFromC[SRC any](cvalue SRC) *InputTextCallbackData {
	return &InputTextCallbackData{CData: internal.ReinterpretCast[*C.ImGuiInputTextCallbackData](cvalue)}
}

type InputTextDeactivateData struct {
	CData *C.ImGuiInputTextDeactivateData
}

// Handle returns C version of InputTextDeactivateData and its finalizer func.
func (self *InputTextDeactivateData) Handle() (result *C.ImGuiInputTextDeactivateData, fin func()) {
	return self.CData, func() {}
}

// NewInputTextDeactivateDataFromC creates InputTextDeactivateData from its C pointer.
// SRC ~= *C.ImGuiInputTextDeactivateData
func NewInputTextDeactivateDataFromC[SRC any](cvalue SRC) *InputTextDeactivateData {
	return &InputTextDeactivateData{CData: internal.ReinterpretCast[*C.ImGuiInputTextDeactivateData](cvalue)}
}

type InputTextDeactivatedState struct {
	CData *C.ImGuiInputTextDeactivatedState
}

// Handle returns C version of InputTextDeactivatedState and its finalizer func.
func (self *InputTextDeactivatedState) Handle() (result *C.ImGuiInputTextDeactivatedState, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputTextDeactivatedState) C() (C.ImGuiInputTextDeactivatedState, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputTextDeactivatedState creates InputTextDeactivatedState with its 0 value.
func NewEmptyInputTextDeactivatedState() *InputTextDeactivatedState {
	return &InputTextDeactivatedState{CData: new(C.ImGuiInputTextDeactivatedState)}
}

// NewInputTextDeactivatedStateFromC creates InputTextDeactivatedState from its C pointer.
// SRC ~= *C.ImGuiInputTextDeactivatedState
func NewInputTextDeactivatedStateFromC[SRC any](cvalue SRC) *InputTextDeactivatedState {
	return &InputTextDeactivatedState{CData: internal.ReinterpretCast[*C.ImGuiInputTextDeactivatedState](cvalue)}
}

type InputTextState struct {
	CData *C.ImGuiInputTextState
}

// Handle returns C version of InputTextState and its finalizer func.
func (self *InputTextState) Handle() (result *C.ImGuiInputTextState, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self InputTextState) C() (C.ImGuiInputTextState, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyInputTextState creates InputTextState with its 0 value.
func NewEmptyInputTextState() *InputTextState {
	return &InputTextState{CData: new(C.ImGuiInputTextState)}
}

// NewInputTextStateFromC creates InputTextState from its C pointer.
// SRC ~= *C.ImGuiInputTextState
func NewInputTextStateFromC[SRC any](cvalue SRC) *InputTextState {
	return &InputTextState{CData: internal.ReinterpretCast[*C.ImGuiInputTextState](cvalue)}
}

type KeyChord int32

// Handle returns C version of KeyChord and its finalizer func.
func (selfSrc *KeyChord) Handle() (result *C.ImGuiKeyChord, fin func()) {
	self := (*int32)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.int, int32](self)
	return (*C.ImGuiKeyChord)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self KeyChord) C() (C.ImGuiKeyChord, func()) {
	return (C.ImGuiKeyChord)(C.int(self)), func() {}
}

// NewKeyChordFromC creates KeyChord from its C pointer.
// SRC ~= *C.ImGuiKeyChord
func NewKeyChordFromC[SRC any](cvalue SRC) *KeyChord {
	return (*KeyChord)((*int32)(internal.ReinterpretCast[*C.ImGuiKeyChord](cvalue)))
}

type KeyData struct {
	CData *C.ImGuiKeyData
}

// Handle returns C version of KeyData and its finalizer func.
func (self *KeyData) Handle() (result *C.ImGuiKeyData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self KeyData) C() (C.ImGuiKeyData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyKeyData creates KeyData with its 0 value.
func NewEmptyKeyData() *KeyData {
	return &KeyData{CData: new(C.ImGuiKeyData)}
}

// NewKeyDataFromC creates KeyData from its C pointer.
// SRC ~= *C.ImGuiKeyData
func NewKeyDataFromC[SRC any](cvalue SRC) *KeyData {
	return &KeyData{CData: internal.ReinterpretCast[*C.ImGuiKeyData](cvalue)}
}

type KeyOwnerData struct {
	CData *C.ImGuiKeyOwnerData
}

// Handle returns C version of KeyOwnerData and its finalizer func.
func (self *KeyOwnerData) Handle() (result *C.ImGuiKeyOwnerData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self KeyOwnerData) C() (C.ImGuiKeyOwnerData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyKeyOwnerData creates KeyOwnerData with its 0 value.
func NewEmptyKeyOwnerData() *KeyOwnerData {
	return &KeyOwnerData{CData: new(C.ImGuiKeyOwnerData)}
}

// NewKeyOwnerDataFromC creates KeyOwnerData from its C pointer.
// SRC ~= *C.ImGuiKeyOwnerData
func NewKeyOwnerDataFromC[SRC any](cvalue SRC) *KeyOwnerData {
	return &KeyOwnerData{CData: internal.ReinterpretCast[*C.ImGuiKeyOwnerData](cvalue)}
}

type KeyRoutingData struct {
	CData *C.ImGuiKeyRoutingData
}

// Handle returns C version of KeyRoutingData and its finalizer func.
func (self *KeyRoutingData) Handle() (result *C.ImGuiKeyRoutingData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self KeyRoutingData) C() (C.ImGuiKeyRoutingData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyKeyRoutingData creates KeyRoutingData with its 0 value.
func NewEmptyKeyRoutingData() *KeyRoutingData {
	return &KeyRoutingData{CData: new(C.ImGuiKeyRoutingData)}
}

// NewKeyRoutingDataFromC creates KeyRoutingData from its C pointer.
// SRC ~= *C.ImGuiKeyRoutingData
func NewKeyRoutingDataFromC[SRC any](cvalue SRC) *KeyRoutingData {
	return &KeyRoutingData{CData: internal.ReinterpretCast[*C.ImGuiKeyRoutingData](cvalue)}
}

type KeyRoutingIndex int16

// Handle returns C version of KeyRoutingIndex and its finalizer func.
func (selfSrc *KeyRoutingIndex) Handle() (result *C.ImGuiKeyRoutingIndex, fin func()) {
	self := (*int16)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.ImS16, int16](self)
	return (*C.ImGuiKeyRoutingIndex)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self KeyRoutingIndex) C() (C.ImGuiKeyRoutingIndex, func()) {
	return (C.ImGuiKeyRoutingIndex)(C.ImS16(self)), func() {}
}

// NewKeyRoutingIndexFromC creates KeyRoutingIndex from its C pointer.
// SRC ~= *C.ImGuiKeyRoutingIndex
func NewKeyRoutingIndexFromC[SRC any](cvalue SRC) *KeyRoutingIndex {
	return (*KeyRoutingIndex)((*int16)(internal.ReinterpretCast[*C.ImGuiKeyRoutingIndex](cvalue)))
}

type KeyRoutingTable struct {
	CData *C.ImGuiKeyRoutingTable
}

// Handle returns C version of KeyRoutingTable and its finalizer func.
func (self *KeyRoutingTable) Handle() (result *C.ImGuiKeyRoutingTable, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self KeyRoutingTable) C() (C.ImGuiKeyRoutingTable, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyKeyRoutingTable creates KeyRoutingTable with its 0 value.
func NewEmptyKeyRoutingTable() *KeyRoutingTable {
	return &KeyRoutingTable{CData: new(C.ImGuiKeyRoutingTable)}
}

// NewKeyRoutingTableFromC creates KeyRoutingTable from its C pointer.
// SRC ~= *C.ImGuiKeyRoutingTable
func NewKeyRoutingTableFromC[SRC any](cvalue SRC) *KeyRoutingTable {
	return &KeyRoutingTable{CData: internal.ReinterpretCast[*C.ImGuiKeyRoutingTable](cvalue)}
}

type LastItemData struct {
	CData *C.ImGuiLastItemData
}

// Handle returns C version of LastItemData and its finalizer func.
func (self *LastItemData) Handle() (result *C.ImGuiLastItemData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self LastItemData) C() (C.ImGuiLastItemData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyLastItemData creates LastItemData with its 0 value.
func NewEmptyLastItemData() *LastItemData {
	return &LastItemData{CData: new(C.ImGuiLastItemData)}
}

// NewLastItemDataFromC creates LastItemData from its C pointer.
// SRC ~= *C.ImGuiLastItemData
func NewLastItemDataFromC[SRC any](cvalue SRC) *LastItemData {
	return &LastItemData{CData: internal.ReinterpretCast[*C.ImGuiLastItemData](cvalue)}
}

type ListClipper struct {
	CData *C.ImGuiListClipper
}

// Handle returns C version of ListClipper and its finalizer func.
func (self *ListClipper) Handle() (result *C.ImGuiListClipper, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self ListClipper) C() (C.ImGuiListClipper, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyListClipper creates ListClipper with its 0 value.
func NewEmptyListClipper() *ListClipper {
	return &ListClipper{CData: new(C.ImGuiListClipper)}
}

// NewListClipperFromC creates ListClipper from its C pointer.
// SRC ~= *C.ImGuiListClipper
func NewListClipperFromC[SRC any](cvalue SRC) *ListClipper {
	return &ListClipper{CData: internal.ReinterpretCast[*C.ImGuiListClipper](cvalue)}
}

type ListClipperData struct {
	CData *C.ImGuiListClipperData
}

// Handle returns C version of ListClipperData and its finalizer func.
func (self *ListClipperData) Handle() (result *C.ImGuiListClipperData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self ListClipperData) C() (C.ImGuiListClipperData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyListClipperData creates ListClipperData with its 0 value.
func NewEmptyListClipperData() *ListClipperData {
	return &ListClipperData{CData: new(C.ImGuiListClipperData)}
}

// NewListClipperDataFromC creates ListClipperData from its C pointer.
// SRC ~= *C.ImGuiListClipperData
func NewListClipperDataFromC[SRC any](cvalue SRC) *ListClipperData {
	return &ListClipperData{CData: internal.ReinterpretCast[*C.ImGuiListClipperData](cvalue)}
}

type ListClipperRange struct {
	CData *C.ImGuiListClipperRange
}

// Handle returns C version of ListClipperRange and its finalizer func.
func (self *ListClipperRange) Handle() (result *C.ImGuiListClipperRange, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self ListClipperRange) C() (C.ImGuiListClipperRange, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyListClipperRange creates ListClipperRange with its 0 value.
func NewEmptyListClipperRange() *ListClipperRange {
	return &ListClipperRange{CData: new(C.ImGuiListClipperRange)}
}

// NewListClipperRangeFromC creates ListClipperRange from its C pointer.
// SRC ~= *C.ImGuiListClipperRange
func NewListClipperRangeFromC[SRC any](cvalue SRC) *ListClipperRange {
	return &ListClipperRange{CData: internal.ReinterpretCast[*C.ImGuiListClipperRange](cvalue)}
}

type LocEntry struct {
	CData *C.ImGuiLocEntry
}

// Handle returns C version of LocEntry and its finalizer func.
func (self *LocEntry) Handle() (result *C.ImGuiLocEntry, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self LocEntry) C() (C.ImGuiLocEntry, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyLocEntry creates LocEntry with its 0 value.
func NewEmptyLocEntry() *LocEntry {
	return &LocEntry{CData: new(C.ImGuiLocEntry)}
}

// NewLocEntryFromC creates LocEntry from its C pointer.
// SRC ~= *C.ImGuiLocEntry
func NewLocEntryFromC[SRC any](cvalue SRC) *LocEntry {
	return &LocEntry{CData: internal.ReinterpretCast[*C.ImGuiLocEntry](cvalue)}
}

type MenuColumns struct {
	CData *C.ImGuiMenuColumns
}

// Handle returns C version of MenuColumns and its finalizer func.
func (self *MenuColumns) Handle() (result *C.ImGuiMenuColumns, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self MenuColumns) C() (C.ImGuiMenuColumns, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyMenuColumns creates MenuColumns with its 0 value.
func NewEmptyMenuColumns() *MenuColumns {
	return &MenuColumns{CData: new(C.ImGuiMenuColumns)}
}

// NewMenuColumnsFromC creates MenuColumns from its C pointer.
// SRC ~= *C.ImGuiMenuColumns
func NewMenuColumnsFromC[SRC any](cvalue SRC) *MenuColumns {
	return &MenuColumns{CData: internal.ReinterpretCast[*C.ImGuiMenuColumns](cvalue)}
}

type MetricsConfig struct {
	CData *C.ImGuiMetricsConfig
}

// Handle returns C version of MetricsConfig and its finalizer func.
func (self *MetricsConfig) Handle() (result *C.ImGuiMetricsConfig, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self MetricsConfig) C() (C.ImGuiMetricsConfig, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyMetricsConfig creates MetricsConfig with its 0 value.
func NewEmptyMetricsConfig() *MetricsConfig {
	return &MetricsConfig{CData: new(C.ImGuiMetricsConfig)}
}

// NewMetricsConfigFromC creates MetricsConfig from its C pointer.
// SRC ~= *C.ImGuiMetricsConfig
func NewMetricsConfigFromC[SRC any](cvalue SRC) *MetricsConfig {
	return &MetricsConfig{CData: internal.ReinterpretCast[*C.ImGuiMetricsConfig](cvalue)}
}

type MultiSelectIO struct {
	CData *C.ImGuiMultiSelectIO
}

// Handle returns C version of MultiSelectIO and its finalizer func.
func (self *MultiSelectIO) Handle() (result *C.ImGuiMultiSelectIO, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self MultiSelectIO) C() (C.ImGuiMultiSelectIO, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyMultiSelectIO creates MultiSelectIO with its 0 value.
func NewEmptyMultiSelectIO() *MultiSelectIO {
	return &MultiSelectIO{CData: new(C.ImGuiMultiSelectIO)}
}

// NewMultiSelectIOFromC creates MultiSelectIO from its C pointer.
// SRC ~= *C.ImGuiMultiSelectIO
func NewMultiSelectIOFromC[SRC any](cvalue SRC) *MultiSelectIO {
	return &MultiSelectIO{CData: internal.ReinterpretCast[*C.ImGuiMultiSelectIO](cvalue)}
}

type MultiSelectState struct {
	CData *C.ImGuiMultiSelectState
}

// Handle returns C version of MultiSelectState and its finalizer func.
func (self *MultiSelectState) Handle() (result *C.ImGuiMultiSelectState, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self MultiSelectState) C() (C.ImGuiMultiSelectState, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyMultiSelectState creates MultiSelectState with its 0 value.
func NewEmptyMultiSelectState() *MultiSelectState {
	return &MultiSelectState{CData: new(C.ImGuiMultiSelectState)}
}

// NewMultiSelectStateFromC creates MultiSelectState from its C pointer.
// SRC ~= *C.ImGuiMultiSelectState
func NewMultiSelectStateFromC[SRC any](cvalue SRC) *MultiSelectState {
	return &MultiSelectState{CData: internal.ReinterpretCast[*C.ImGuiMultiSelectState](cvalue)}
}

type MultiSelectTempData struct {
	CData *C.ImGuiMultiSelectTempData
}

// Handle returns C version of MultiSelectTempData and its finalizer func.
func (self *MultiSelectTempData) Handle() (result *C.ImGuiMultiSelectTempData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self MultiSelectTempData) C() (C.ImGuiMultiSelectTempData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyMultiSelectTempData creates MultiSelectTempData with its 0 value.
func NewEmptyMultiSelectTempData() *MultiSelectTempData {
	return &MultiSelectTempData{CData: new(C.ImGuiMultiSelectTempData)}
}

// NewMultiSelectTempDataFromC creates MultiSelectTempData from its C pointer.
// SRC ~= *C.ImGuiMultiSelectTempData
func NewMultiSelectTempDataFromC[SRC any](cvalue SRC) *MultiSelectTempData {
	return &MultiSelectTempData{CData: internal.ReinterpretCast[*C.ImGuiMultiSelectTempData](cvalue)}
}

type NavItemData struct {
	CData *C.ImGuiNavItemData
}

// Handle returns C version of NavItemData and its finalizer func.
func (self *NavItemData) Handle() (result *C.ImGuiNavItemData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self NavItemData) C() (C.ImGuiNavItemData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyNavItemData creates NavItemData with its 0 value.
func NewEmptyNavItemData() *NavItemData {
	return &NavItemData{CData: new(C.ImGuiNavItemData)}
}

// NewNavItemDataFromC creates NavItemData from its C pointer.
// SRC ~= *C.ImGuiNavItemData
func NewNavItemDataFromC[SRC any](cvalue SRC) *NavItemData {
	return &NavItemData{CData: internal.ReinterpretCast[*C.ImGuiNavItemData](cvalue)}
}

type NextItemData struct {
	CData *C.ImGuiNextItemData
}

// Handle returns C version of NextItemData and its finalizer func.
func (self *NextItemData) Handle() (result *C.ImGuiNextItemData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self NextItemData) C() (C.ImGuiNextItemData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyNextItemData creates NextItemData with its 0 value.
func NewEmptyNextItemData() *NextItemData {
	return &NextItemData{CData: new(C.ImGuiNextItemData)}
}

// NewNextItemDataFromC creates NextItemData from its C pointer.
// SRC ~= *C.ImGuiNextItemData
func NewNextItemDataFromC[SRC any](cvalue SRC) *NextItemData {
	return &NextItemData{CData: internal.ReinterpretCast[*C.ImGuiNextItemData](cvalue)}
}

type NextWindowData struct {
	CData *C.ImGuiNextWindowData
}

// Handle returns C version of NextWindowData and its finalizer func.
func (self *NextWindowData) Handle() (result *C.ImGuiNextWindowData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self NextWindowData) C() (C.ImGuiNextWindowData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyNextWindowData creates NextWindowData with its 0 value.
func NewEmptyNextWindowData() *NextWindowData {
	return &NextWindowData{CData: new(C.ImGuiNextWindowData)}
}

// NewNextWindowDataFromC creates NextWindowData from its C pointer.
// SRC ~= *C.ImGuiNextWindowData
func NewNextWindowDataFromC[SRC any](cvalue SRC) *NextWindowData {
	return &NextWindowData{CData: internal.ReinterpretCast[*C.ImGuiNextWindowData](cvalue)}
}

type OldColumnData struct {
	CData *C.ImGuiOldColumnData
}

// Handle returns C version of OldColumnData and its finalizer func.
func (self *OldColumnData) Handle() (result *C.ImGuiOldColumnData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self OldColumnData) C() (C.ImGuiOldColumnData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyOldColumnData creates OldColumnData with its 0 value.
func NewEmptyOldColumnData() *OldColumnData {
	return &OldColumnData{CData: new(C.ImGuiOldColumnData)}
}

// NewOldColumnDataFromC creates OldColumnData from its C pointer.
// SRC ~= *C.ImGuiOldColumnData
func NewOldColumnDataFromC[SRC any](cvalue SRC) *OldColumnData {
	return &OldColumnData{CData: internal.ReinterpretCast[*C.ImGuiOldColumnData](cvalue)}
}

type OldColumns struct {
	CData *C.ImGuiOldColumns
}

// Handle returns C version of OldColumns and its finalizer func.
func (self *OldColumns) Handle() (result *C.ImGuiOldColumns, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self OldColumns) C() (C.ImGuiOldColumns, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyOldColumns creates OldColumns with its 0 value.
func NewEmptyOldColumns() *OldColumns {
	return &OldColumns{CData: new(C.ImGuiOldColumns)}
}

// NewOldColumnsFromC creates OldColumns from its C pointer.
// SRC ~= *C.ImGuiOldColumns
func NewOldColumnsFromC[SRC any](cvalue SRC) *OldColumns {
	return &OldColumns{CData: internal.ReinterpretCast[*C.ImGuiOldColumns](cvalue)}
}

type OnceUponAFrame struct {
	CData *C.ImGuiOnceUponAFrame
}

// Handle returns C version of OnceUponAFrame and its finalizer func.
func (self *OnceUponAFrame) Handle() (result *C.ImGuiOnceUponAFrame, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self OnceUponAFrame) C() (C.ImGuiOnceUponAFrame, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyOnceUponAFrame creates OnceUponAFrame with its 0 value.
func NewEmptyOnceUponAFrame() *OnceUponAFrame {
	return &OnceUponAFrame{CData: new(C.ImGuiOnceUponAFrame)}
}

// NewOnceUponAFrameFromC creates OnceUponAFrame from its C pointer.
// SRC ~= *C.ImGuiOnceUponAFrame
func NewOnceUponAFrameFromC[SRC any](cvalue SRC) *OnceUponAFrame {
	return &OnceUponAFrame{CData: internal.ReinterpretCast[*C.ImGuiOnceUponAFrame](cvalue)}
}

type Payload struct {
	CData *C.ImGuiPayload
}

// Handle returns C version of Payload and its finalizer func.
func (self *Payload) Handle() (result *C.ImGuiPayload, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Payload) C() (C.ImGuiPayload, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyPayload creates Payload with its 0 value.
func NewEmptyPayload() *Payload {
	return &Payload{CData: new(C.ImGuiPayload)}
}

// NewPayloadFromC creates Payload from its C pointer.
// SRC ~= *C.ImGuiPayload
func NewPayloadFromC[SRC any](cvalue SRC) *Payload {
	return &Payload{CData: internal.ReinterpretCast[*C.ImGuiPayload](cvalue)}
}

type PlatformIO struct {
	CData *C.ImGuiPlatformIO
}

// Handle returns C version of PlatformIO and its finalizer func.
func (self *PlatformIO) Handle() (result *C.ImGuiPlatformIO, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self PlatformIO) C() (C.ImGuiPlatformIO, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyPlatformIO creates PlatformIO with its 0 value.
func NewEmptyPlatformIO() *PlatformIO {
	return &PlatformIO{CData: new(C.ImGuiPlatformIO)}
}

// NewPlatformIOFromC creates PlatformIO from its C pointer.
// SRC ~= *C.ImGuiPlatformIO
func NewPlatformIOFromC[SRC any](cvalue SRC) *PlatformIO {
	return &PlatformIO{CData: internal.ReinterpretCast[*C.ImGuiPlatformIO](cvalue)}
}

type PlatformImeData struct {
	CData *C.ImGuiPlatformImeData
}

// Handle returns C version of PlatformImeData and its finalizer func.
func (self *PlatformImeData) Handle() (result *C.ImGuiPlatformImeData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self PlatformImeData) C() (C.ImGuiPlatformImeData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyPlatformImeData creates PlatformImeData with its 0 value.
func NewEmptyPlatformImeData() *PlatformImeData {
	return &PlatformImeData{CData: new(C.ImGuiPlatformImeData)}
}

// NewPlatformImeDataFromC creates PlatformImeData from its C pointer.
// SRC ~= *C.ImGuiPlatformImeData
func NewPlatformImeDataFromC[SRC any](cvalue SRC) *PlatformImeData {
	return &PlatformImeData{CData: internal.ReinterpretCast[*C.ImGuiPlatformImeData](cvalue)}
}

type PlatformMonitor struct {
	CData *C.ImGuiPlatformMonitor
}

// Handle returns C version of PlatformMonitor and its finalizer func.
func (self *PlatformMonitor) Handle() (result *C.ImGuiPlatformMonitor, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self PlatformMonitor) C() (C.ImGuiPlatformMonitor, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyPlatformMonitor creates PlatformMonitor with its 0 value.
func NewEmptyPlatformMonitor() *PlatformMonitor {
	return &PlatformMonitor{CData: new(C.ImGuiPlatformMonitor)}
}

// NewPlatformMonitorFromC creates PlatformMonitor from its C pointer.
// SRC ~= *C.ImGuiPlatformMonitor
func NewPlatformMonitorFromC[SRC any](cvalue SRC) *PlatformMonitor {
	return &PlatformMonitor{CData: internal.ReinterpretCast[*C.ImGuiPlatformMonitor](cvalue)}
}

type PopupData struct {
	CData *C.ImGuiPopupData
}

// Handle returns C version of PopupData and its finalizer func.
func (self *PopupData) Handle() (result *C.ImGuiPopupData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self PopupData) C() (C.ImGuiPopupData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyPopupData creates PopupData with its 0 value.
func NewEmptyPopupData() *PopupData {
	return &PopupData{CData: new(C.ImGuiPopupData)}
}

// NewPopupDataFromC creates PopupData from its C pointer.
// SRC ~= *C.ImGuiPopupData
func NewPopupDataFromC[SRC any](cvalue SRC) *PopupData {
	return &PopupData{CData: internal.ReinterpretCast[*C.ImGuiPopupData](cvalue)}
}

type PtrOrIndex struct {
	CData *C.ImGuiPtrOrIndex
}

// Handle returns C version of PtrOrIndex and its finalizer func.
func (self *PtrOrIndex) Handle() (result *C.ImGuiPtrOrIndex, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self PtrOrIndex) C() (C.ImGuiPtrOrIndex, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyPtrOrIndex creates PtrOrIndex with its 0 value.
func NewEmptyPtrOrIndex() *PtrOrIndex {
	return &PtrOrIndex{CData: new(C.ImGuiPtrOrIndex)}
}

// NewPtrOrIndexFromC creates PtrOrIndex from its C pointer.
// SRC ~= *C.ImGuiPtrOrIndex
func NewPtrOrIndexFromC[SRC any](cvalue SRC) *PtrOrIndex {
	return &PtrOrIndex{CData: internal.ReinterpretCast[*C.ImGuiPtrOrIndex](cvalue)}
}

type SelectionBasicStorage struct {
	CData *C.ImGuiSelectionBasicStorage
}

// Handle returns C version of SelectionBasicStorage and its finalizer func.
func (self *SelectionBasicStorage) Handle() (result *C.ImGuiSelectionBasicStorage, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self SelectionBasicStorage) C() (C.ImGuiSelectionBasicStorage, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptySelectionBasicStorage creates SelectionBasicStorage with its 0 value.
func NewEmptySelectionBasicStorage() *SelectionBasicStorage {
	return &SelectionBasicStorage{CData: new(C.ImGuiSelectionBasicStorage)}
}

// NewSelectionBasicStorageFromC creates SelectionBasicStorage from its C pointer.
// SRC ~= *C.ImGuiSelectionBasicStorage
func NewSelectionBasicStorageFromC[SRC any](cvalue SRC) *SelectionBasicStorage {
	return &SelectionBasicStorage{CData: internal.ReinterpretCast[*C.ImGuiSelectionBasicStorage](cvalue)}
}

type SelectionExternalStorage struct {
	CData *C.ImGuiSelectionExternalStorage
}

// Handle returns C version of SelectionExternalStorage and its finalizer func.
func (self *SelectionExternalStorage) Handle() (result *C.ImGuiSelectionExternalStorage, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self SelectionExternalStorage) C() (C.ImGuiSelectionExternalStorage, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptySelectionExternalStorage creates SelectionExternalStorage with its 0 value.
func NewEmptySelectionExternalStorage() *SelectionExternalStorage {
	return &SelectionExternalStorage{CData: new(C.ImGuiSelectionExternalStorage)}
}

// NewSelectionExternalStorageFromC creates SelectionExternalStorage from its C pointer.
// SRC ~= *C.ImGuiSelectionExternalStorage
func NewSelectionExternalStorageFromC[SRC any](cvalue SRC) *SelectionExternalStorage {
	return &SelectionExternalStorage{CData: internal.ReinterpretCast[*C.ImGuiSelectionExternalStorage](cvalue)}
}

type SelectionRequest struct {
	CData *C.ImGuiSelectionRequest
}

// Handle returns C version of SelectionRequest and its finalizer func.
func (self *SelectionRequest) Handle() (result *C.ImGuiSelectionRequest, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self SelectionRequest) C() (C.ImGuiSelectionRequest, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptySelectionRequest creates SelectionRequest with its 0 value.
func NewEmptySelectionRequest() *SelectionRequest {
	return &SelectionRequest{CData: new(C.ImGuiSelectionRequest)}
}

// NewSelectionRequestFromC creates SelectionRequest from its C pointer.
// SRC ~= *C.ImGuiSelectionRequest
func NewSelectionRequestFromC[SRC any](cvalue SRC) *SelectionRequest {
	return &SelectionRequest{CData: internal.ReinterpretCast[*C.ImGuiSelectionRequest](cvalue)}
}

type SelectionUserData int64

// Handle returns C version of SelectionUserData and its finalizer func.
func (selfSrc *SelectionUserData) Handle() (result *C.ImGuiSelectionUserData, fin func()) {
	self := (*int64)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.ImS64, int64](self)
	return (*C.ImGuiSelectionUserData)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self SelectionUserData) C() (C.ImGuiSelectionUserData, func()) {
	return (C.ImGuiSelectionUserData)(C.ImS64(self)), func() {}
}

// NewSelectionUserDataFromC creates SelectionUserData from its C pointer.
// SRC ~= *C.ImGuiSelectionUserData
func NewSelectionUserDataFromC[SRC any](cvalue SRC) *SelectionUserData {
	return (*SelectionUserData)((*int64)(internal.ReinterpretCast[*C.ImGuiSelectionUserData](cvalue)))
}

type SettingsHandler struct {
	CData *C.ImGuiSettingsHandler
}

// Handle returns C version of SettingsHandler and its finalizer func.
func (self *SettingsHandler) Handle() (result *C.ImGuiSettingsHandler, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self SettingsHandler) C() (C.ImGuiSettingsHandler, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptySettingsHandler creates SettingsHandler with its 0 value.
func NewEmptySettingsHandler() *SettingsHandler {
	return &SettingsHandler{CData: new(C.ImGuiSettingsHandler)}
}

// NewSettingsHandlerFromC creates SettingsHandler from its C pointer.
// SRC ~= *C.ImGuiSettingsHandler
func NewSettingsHandlerFromC[SRC any](cvalue SRC) *SettingsHandler {
	return &SettingsHandler{CData: internal.ReinterpretCast[*C.ImGuiSettingsHandler](cvalue)}
}

type ShrinkWidthItem struct {
	CData *C.ImGuiShrinkWidthItem
}

// Handle returns C version of ShrinkWidthItem and its finalizer func.
func (self *ShrinkWidthItem) Handle() (result *C.ImGuiShrinkWidthItem, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self ShrinkWidthItem) C() (C.ImGuiShrinkWidthItem, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyShrinkWidthItem creates ShrinkWidthItem with its 0 value.
func NewEmptyShrinkWidthItem() *ShrinkWidthItem {
	return &ShrinkWidthItem{CData: new(C.ImGuiShrinkWidthItem)}
}

// NewShrinkWidthItemFromC creates ShrinkWidthItem from its C pointer.
// SRC ~= *C.ImGuiShrinkWidthItem
func NewShrinkWidthItemFromC[SRC any](cvalue SRC) *ShrinkWidthItem {
	return &ShrinkWidthItem{CData: internal.ReinterpretCast[*C.ImGuiShrinkWidthItem](cvalue)}
}

type SizeCallbackData struct {
	CData *C.ImGuiSizeCallbackData
}

// Handle returns C version of SizeCallbackData and its finalizer func.
func (self *SizeCallbackData) Handle() (result *C.ImGuiSizeCallbackData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self SizeCallbackData) C() (C.ImGuiSizeCallbackData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptySizeCallbackData creates SizeCallbackData with its 0 value.
func NewEmptySizeCallbackData() *SizeCallbackData {
	return &SizeCallbackData{CData: new(C.ImGuiSizeCallbackData)}
}

// NewSizeCallbackDataFromC creates SizeCallbackData from its C pointer.
// SRC ~= *C.ImGuiSizeCallbackData
func NewSizeCallbackDataFromC[SRC any](cvalue SRC) *SizeCallbackData {
	return &SizeCallbackData{CData: internal.ReinterpretCast[*C.ImGuiSizeCallbackData](cvalue)}
}

type StackLevelInfo struct {
	CData *C.ImGuiStackLevelInfo
}

// Handle returns C version of StackLevelInfo and its finalizer func.
func (self *StackLevelInfo) Handle() (result *C.ImGuiStackLevelInfo, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self StackLevelInfo) C() (C.ImGuiStackLevelInfo, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyStackLevelInfo creates StackLevelInfo with its 0 value.
func NewEmptyStackLevelInfo() *StackLevelInfo {
	return &StackLevelInfo{CData: new(C.ImGuiStackLevelInfo)}
}

// NewStackLevelInfoFromC creates StackLevelInfo from its C pointer.
// SRC ~= *C.ImGuiStackLevelInfo
func NewStackLevelInfoFromC[SRC any](cvalue SRC) *StackLevelInfo {
	return &StackLevelInfo{CData: internal.ReinterpretCast[*C.ImGuiStackLevelInfo](cvalue)}
}

type Storage struct {
	CData *C.ImGuiStorage
}

// Handle returns C version of Storage and its finalizer func.
func (self *Storage) Handle() (result *C.ImGuiStorage, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Storage) C() (C.ImGuiStorage, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyStorage creates Storage with its 0 value.
func NewEmptyStorage() *Storage {
	return &Storage{CData: new(C.ImGuiStorage)}
}

// NewStorageFromC creates Storage from its C pointer.
// SRC ~= *C.ImGuiStorage
func NewStorageFromC[SRC any](cvalue SRC) *Storage {
	return &Storage{CData: internal.ReinterpretCast[*C.ImGuiStorage](cvalue)}
}

type StoragePair struct {
	CData *C.ImGuiStoragePair
}

// Handle returns C version of StoragePair and its finalizer func.
func (self *StoragePair) Handle() (result *C.ImGuiStoragePair, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self StoragePair) C() (C.ImGuiStoragePair, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyStoragePair creates StoragePair with its 0 value.
func NewEmptyStoragePair() *StoragePair {
	return &StoragePair{CData: new(C.ImGuiStoragePair)}
}

// NewStoragePairFromC creates StoragePair from its C pointer.
// SRC ~= *C.ImGuiStoragePair
func NewStoragePairFromC[SRC any](cvalue SRC) *StoragePair {
	return &StoragePair{CData: internal.ReinterpretCast[*C.ImGuiStoragePair](cvalue)}
}

type Style struct {
	CData *C.ImGuiStyle
}

// Handle returns C version of Style and its finalizer func.
func (self *Style) Handle() (result *C.ImGuiStyle, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Style) C() (C.ImGuiStyle, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyStyle creates Style with its 0 value.
func NewEmptyStyle() *Style {
	return &Style{CData: new(C.ImGuiStyle)}
}

// NewStyleFromC creates Style from its C pointer.
// SRC ~= *C.ImGuiStyle
func NewStyleFromC[SRC any](cvalue SRC) *Style {
	return &Style{CData: internal.ReinterpretCast[*C.ImGuiStyle](cvalue)}
}

type StyleMod struct {
	CData *C.ImGuiStyleMod
}

// Handle returns C version of StyleMod and its finalizer func.
func (self *StyleMod) Handle() (result *C.ImGuiStyleMod, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self StyleMod) C() (C.ImGuiStyleMod, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyStyleMod creates StyleMod with its 0 value.
func NewEmptyStyleMod() *StyleMod {
	return &StyleMod{CData: new(C.ImGuiStyleMod)}
}

// NewStyleModFromC creates StyleMod from its C pointer.
// SRC ~= *C.ImGuiStyleMod
func NewStyleModFromC[SRC any](cvalue SRC) *StyleMod {
	return &StyleMod{CData: internal.ReinterpretCast[*C.ImGuiStyleMod](cvalue)}
}

type StyleVarInfo struct {
	CData *C.ImGuiStyleVarInfo
}

// Handle returns C version of StyleVarInfo and its finalizer func.
func (self *StyleVarInfo) Handle() (result *C.ImGuiStyleVarInfo, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self StyleVarInfo) C() (C.ImGuiStyleVarInfo, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyStyleVarInfo creates StyleVarInfo with its 0 value.
func NewEmptyStyleVarInfo() *StyleVarInfo {
	return &StyleVarInfo{CData: new(C.ImGuiStyleVarInfo)}
}

// NewStyleVarInfoFromC creates StyleVarInfo from its C pointer.
// SRC ~= *C.ImGuiStyleVarInfo
func NewStyleVarInfoFromC[SRC any](cvalue SRC) *StyleVarInfo {
	return &StyleVarInfo{CData: internal.ReinterpretCast[*C.ImGuiStyleVarInfo](cvalue)}
}

type TabBar struct {
	CData *C.ImGuiTabBar
}

// Handle returns C version of TabBar and its finalizer func.
func (self *TabBar) Handle() (result *C.ImGuiTabBar, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TabBar) C() (C.ImGuiTabBar, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTabBar creates TabBar with its 0 value.
func NewEmptyTabBar() *TabBar {
	return &TabBar{CData: new(C.ImGuiTabBar)}
}

// NewTabBarFromC creates TabBar from its C pointer.
// SRC ~= *C.ImGuiTabBar
func NewTabBarFromC[SRC any](cvalue SRC) *TabBar {
	return &TabBar{CData: internal.ReinterpretCast[*C.ImGuiTabBar](cvalue)}
}

type TabItem struct {
	CData *C.ImGuiTabItem
}

// Handle returns C version of TabItem and its finalizer func.
func (self *TabItem) Handle() (result *C.ImGuiTabItem, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TabItem) C() (C.ImGuiTabItem, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTabItem creates TabItem with its 0 value.
func NewEmptyTabItem() *TabItem {
	return &TabItem{CData: new(C.ImGuiTabItem)}
}

// NewTabItemFromC creates TabItem from its C pointer.
// SRC ~= *C.ImGuiTabItem
func NewTabItemFromC[SRC any](cvalue SRC) *TabItem {
	return &TabItem{CData: internal.ReinterpretCast[*C.ImGuiTabItem](cvalue)}
}

type Table struct {
	CData *C.ImGuiTable
}

// Handle returns C version of Table and its finalizer func.
func (self *Table) Handle() (result *C.ImGuiTable, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Table) C() (C.ImGuiTable, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTable creates Table with its 0 value.
func NewEmptyTable() *Table {
	return &Table{CData: new(C.ImGuiTable)}
}

// NewTableFromC creates Table from its C pointer.
// SRC ~= *C.ImGuiTable
func NewTableFromC[SRC any](cvalue SRC) *Table {
	return &Table{CData: internal.ReinterpretCast[*C.ImGuiTable](cvalue)}
}

type TableCellData struct {
	CData *C.ImGuiTableCellData
}

// Handle returns C version of TableCellData and its finalizer func.
func (self *TableCellData) Handle() (result *C.ImGuiTableCellData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TableCellData) C() (C.ImGuiTableCellData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTableCellData creates TableCellData with its 0 value.
func NewEmptyTableCellData() *TableCellData {
	return &TableCellData{CData: new(C.ImGuiTableCellData)}
}

// NewTableCellDataFromC creates TableCellData from its C pointer.
// SRC ~= *C.ImGuiTableCellData
func NewTableCellDataFromC[SRC any](cvalue SRC) *TableCellData {
	return &TableCellData{CData: internal.ReinterpretCast[*C.ImGuiTableCellData](cvalue)}
}

type TableColumn struct {
	CData *C.ImGuiTableColumn
}

// Handle returns C version of TableColumn and its finalizer func.
func (self *TableColumn) Handle() (result *C.ImGuiTableColumn, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TableColumn) C() (C.ImGuiTableColumn, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTableColumn creates TableColumn with its 0 value.
func NewEmptyTableColumn() *TableColumn {
	return &TableColumn{CData: new(C.ImGuiTableColumn)}
}

// NewTableColumnFromC creates TableColumn from its C pointer.
// SRC ~= *C.ImGuiTableColumn
func NewTableColumnFromC[SRC any](cvalue SRC) *TableColumn {
	return &TableColumn{CData: internal.ReinterpretCast[*C.ImGuiTableColumn](cvalue)}
}

type TableColumnIdx int16

// Handle returns C version of TableColumnIdx and its finalizer func.
func (selfSrc *TableColumnIdx) Handle() (result *C.ImGuiTableColumnIdx, fin func()) {
	self := (*int16)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.ImS16, int16](self)
	return (*C.ImGuiTableColumnIdx)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self TableColumnIdx) C() (C.ImGuiTableColumnIdx, func()) {
	return (C.ImGuiTableColumnIdx)(C.ImS16(self)), func() {}
}

// NewTableColumnIdxFromC creates TableColumnIdx from its C pointer.
// SRC ~= *C.ImGuiTableColumnIdx
func NewTableColumnIdxFromC[SRC any](cvalue SRC) *TableColumnIdx {
	return (*TableColumnIdx)((*int16)(internal.ReinterpretCast[*C.ImGuiTableColumnIdx](cvalue)))
}

type TableColumnSettings struct {
	CData *C.ImGuiTableColumnSettings
}

// Handle returns C version of TableColumnSettings and its finalizer func.
func (self *TableColumnSettings) Handle() (result *C.ImGuiTableColumnSettings, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TableColumnSettings) C() (C.ImGuiTableColumnSettings, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTableColumnSettings creates TableColumnSettings with its 0 value.
func NewEmptyTableColumnSettings() *TableColumnSettings {
	return &TableColumnSettings{CData: new(C.ImGuiTableColumnSettings)}
}

// NewTableColumnSettingsFromC creates TableColumnSettings from its C pointer.
// SRC ~= *C.ImGuiTableColumnSettings
func NewTableColumnSettingsFromC[SRC any](cvalue SRC) *TableColumnSettings {
	return &TableColumnSettings{CData: internal.ReinterpretCast[*C.ImGuiTableColumnSettings](cvalue)}
}

type TableColumnSortSpecs struct {
	CData *C.ImGuiTableColumnSortSpecs
}

// Handle returns C version of TableColumnSortSpecs and its finalizer func.
func (self *TableColumnSortSpecs) Handle() (result *C.ImGuiTableColumnSortSpecs, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TableColumnSortSpecs) C() (C.ImGuiTableColumnSortSpecs, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTableColumnSortSpecs creates TableColumnSortSpecs with its 0 value.
func NewEmptyTableColumnSortSpecs() *TableColumnSortSpecs {
	return &TableColumnSortSpecs{CData: new(C.ImGuiTableColumnSortSpecs)}
}

// NewTableColumnSortSpecsFromC creates TableColumnSortSpecs from its C pointer.
// SRC ~= *C.ImGuiTableColumnSortSpecs
func NewTableColumnSortSpecsFromC[SRC any](cvalue SRC) *TableColumnSortSpecs {
	return &TableColumnSortSpecs{CData: internal.ReinterpretCast[*C.ImGuiTableColumnSortSpecs](cvalue)}
}

type TableColumnsSettings struct {
	CData *C.ImGuiTableColumnsSettings
}

// Handle returns C version of TableColumnsSettings and its finalizer func.
func (self *TableColumnsSettings) Handle() (result *C.ImGuiTableColumnsSettings, fin func()) {
	return self.CData, func() {}
}

// NewTableColumnsSettingsFromC creates TableColumnsSettings from its C pointer.
// SRC ~= *C.ImGuiTableColumnsSettings
func NewTableColumnsSettingsFromC[SRC any](cvalue SRC) *TableColumnsSettings {
	return &TableColumnsSettings{CData: internal.ReinterpretCast[*C.ImGuiTableColumnsSettings](cvalue)}
}

type TableDrawChannelIdx uint16

// Handle returns C version of TableDrawChannelIdx and its finalizer func.
func (selfSrc *TableDrawChannelIdx) Handle() (result *C.ImGuiTableDrawChannelIdx, fin func()) {
	self := (*uint16)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.ImU16, uint16](self)
	return (*C.ImGuiTableDrawChannelIdx)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self TableDrawChannelIdx) C() (C.ImGuiTableDrawChannelIdx, func()) {
	return (C.ImGuiTableDrawChannelIdx)(C.ImU16(self)), func() {}
}

// NewTableDrawChannelIdxFromC creates TableDrawChannelIdx from its C pointer.
// SRC ~= *C.ImGuiTableDrawChannelIdx
func NewTableDrawChannelIdxFromC[SRC any](cvalue SRC) *TableDrawChannelIdx {
	return (*TableDrawChannelIdx)((*uint16)(internal.ReinterpretCast[*C.ImGuiTableDrawChannelIdx](cvalue)))
}

type TableHeaderData struct {
	CData *C.ImGuiTableHeaderData
}

// Handle returns C version of TableHeaderData and its finalizer func.
func (self *TableHeaderData) Handle() (result *C.ImGuiTableHeaderData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TableHeaderData) C() (C.ImGuiTableHeaderData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTableHeaderData creates TableHeaderData with its 0 value.
func NewEmptyTableHeaderData() *TableHeaderData {
	return &TableHeaderData{CData: new(C.ImGuiTableHeaderData)}
}

// NewTableHeaderDataFromC creates TableHeaderData from its C pointer.
// SRC ~= *C.ImGuiTableHeaderData
func NewTableHeaderDataFromC[SRC any](cvalue SRC) *TableHeaderData {
	return &TableHeaderData{CData: internal.ReinterpretCast[*C.ImGuiTableHeaderData](cvalue)}
}

type TableInstanceData struct {
	CData *C.ImGuiTableInstanceData
}

// Handle returns C version of TableInstanceData and its finalizer func.
func (self *TableInstanceData) Handle() (result *C.ImGuiTableInstanceData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TableInstanceData) C() (C.ImGuiTableInstanceData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTableInstanceData creates TableInstanceData with its 0 value.
func NewEmptyTableInstanceData() *TableInstanceData {
	return &TableInstanceData{CData: new(C.ImGuiTableInstanceData)}
}

// NewTableInstanceDataFromC creates TableInstanceData from its C pointer.
// SRC ~= *C.ImGuiTableInstanceData
func NewTableInstanceDataFromC[SRC any](cvalue SRC) *TableInstanceData {
	return &TableInstanceData{CData: internal.ReinterpretCast[*C.ImGuiTableInstanceData](cvalue)}
}

type TableSettings struct {
	CData *C.ImGuiTableSettings
}

// Handle returns C version of TableSettings and its finalizer func.
func (self *TableSettings) Handle() (result *C.ImGuiTableSettings, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TableSettings) C() (C.ImGuiTableSettings, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTableSettings creates TableSettings with its 0 value.
func NewEmptyTableSettings() *TableSettings {
	return &TableSettings{CData: new(C.ImGuiTableSettings)}
}

// NewTableSettingsFromC creates TableSettings from its C pointer.
// SRC ~= *C.ImGuiTableSettings
func NewTableSettingsFromC[SRC any](cvalue SRC) *TableSettings {
	return &TableSettings{CData: internal.ReinterpretCast[*C.ImGuiTableSettings](cvalue)}
}

type TableSortSpecs struct {
	CData *C.ImGuiTableSortSpecs
}

// Handle returns C version of TableSortSpecs and its finalizer func.
func (self *TableSortSpecs) Handle() (result *C.ImGuiTableSortSpecs, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TableSortSpecs) C() (C.ImGuiTableSortSpecs, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTableSortSpecs creates TableSortSpecs with its 0 value.
func NewEmptyTableSortSpecs() *TableSortSpecs {
	return &TableSortSpecs{CData: new(C.ImGuiTableSortSpecs)}
}

// NewTableSortSpecsFromC creates TableSortSpecs from its C pointer.
// SRC ~= *C.ImGuiTableSortSpecs
func NewTableSortSpecsFromC[SRC any](cvalue SRC) *TableSortSpecs {
	return &TableSortSpecs{CData: internal.ReinterpretCast[*C.ImGuiTableSortSpecs](cvalue)}
}

type TableTempData struct {
	CData *C.ImGuiTableTempData
}

// Handle returns C version of TableTempData and its finalizer func.
func (self *TableTempData) Handle() (result *C.ImGuiTableTempData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TableTempData) C() (C.ImGuiTableTempData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTableTempData creates TableTempData with its 0 value.
func NewEmptyTableTempData() *TableTempData {
	return &TableTempData{CData: new(C.ImGuiTableTempData)}
}

// NewTableTempDataFromC creates TableTempData from its C pointer.
// SRC ~= *C.ImGuiTableTempData
func NewTableTempDataFromC[SRC any](cvalue SRC) *TableTempData {
	return &TableTempData{CData: internal.ReinterpretCast[*C.ImGuiTableTempData](cvalue)}
}

type TextBuffer struct {
	CData *C.ImGuiTextBuffer
}

// Handle returns C version of TextBuffer and its finalizer func.
func (self *TextBuffer) Handle() (result *C.ImGuiTextBuffer, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TextBuffer) C() (C.ImGuiTextBuffer, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTextBuffer creates TextBuffer with its 0 value.
func NewEmptyTextBuffer() *TextBuffer {
	return &TextBuffer{CData: new(C.ImGuiTextBuffer)}
}

// NewTextBufferFromC creates TextBuffer from its C pointer.
// SRC ~= *C.ImGuiTextBuffer
func NewTextBufferFromC[SRC any](cvalue SRC) *TextBuffer {
	return &TextBuffer{CData: internal.ReinterpretCast[*C.ImGuiTextBuffer](cvalue)}
}

type TextFilter struct {
	CData *C.ImGuiTextFilter
}

// Handle returns C version of TextFilter and its finalizer func.
func (self *TextFilter) Handle() (result *C.ImGuiTextFilter, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TextFilter) C() (C.ImGuiTextFilter, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTextFilter creates TextFilter with its 0 value.
func NewEmptyTextFilter() *TextFilter {
	return &TextFilter{CData: new(C.ImGuiTextFilter)}
}

// NewTextFilterFromC creates TextFilter from its C pointer.
// SRC ~= *C.ImGuiTextFilter
func NewTextFilterFromC[SRC any](cvalue SRC) *TextFilter {
	return &TextFilter{CData: internal.ReinterpretCast[*C.ImGuiTextFilter](cvalue)}
}

type TextIndex struct {
	CData *C.ImGuiTextIndex
}

// Handle returns C version of TextIndex and its finalizer func.
func (self *TextIndex) Handle() (result *C.ImGuiTextIndex, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TextIndex) C() (C.ImGuiTextIndex, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTextIndex creates TextIndex with its 0 value.
func NewEmptyTextIndex() *TextIndex {
	return &TextIndex{CData: new(C.ImGuiTextIndex)}
}

// NewTextIndexFromC creates TextIndex from its C pointer.
// SRC ~= *C.ImGuiTextIndex
func NewTextIndexFromC[SRC any](cvalue SRC) *TextIndex {
	return &TextIndex{CData: internal.ReinterpretCast[*C.ImGuiTextIndex](cvalue)}
}

type TextRange struct {
	CData *C.ImGuiTextRange
}

// Handle returns C version of TextRange and its finalizer func.
func (self *TextRange) Handle() (result *C.ImGuiTextRange, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TextRange) C() (C.ImGuiTextRange, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTextRange creates TextRange with its 0 value.
func NewEmptyTextRange() *TextRange {
	return &TextRange{CData: new(C.ImGuiTextRange)}
}

// NewTextRangeFromC creates TextRange from its C pointer.
// SRC ~= *C.ImGuiTextRange
func NewTextRangeFromC[SRC any](cvalue SRC) *TextRange {
	return &TextRange{CData: internal.ReinterpretCast[*C.ImGuiTextRange](cvalue)}
}

type TreeNodeStackData struct {
	CData *C.ImGuiTreeNodeStackData
}

// Handle returns C version of TreeNodeStackData and its finalizer func.
func (self *TreeNodeStackData) Handle() (result *C.ImGuiTreeNodeStackData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TreeNodeStackData) C() (C.ImGuiTreeNodeStackData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTreeNodeStackData creates TreeNodeStackData with its 0 value.
func NewEmptyTreeNodeStackData() *TreeNodeStackData {
	return &TreeNodeStackData{CData: new(C.ImGuiTreeNodeStackData)}
}

// NewTreeNodeStackDataFromC creates TreeNodeStackData from its C pointer.
// SRC ~= *C.ImGuiTreeNodeStackData
func NewTreeNodeStackDataFromC[SRC any](cvalue SRC) *TreeNodeStackData {
	return &TreeNodeStackData{CData: internal.ReinterpretCast[*C.ImGuiTreeNodeStackData](cvalue)}
}

type TypingSelectRequest struct {
	CData *C.ImGuiTypingSelectRequest
}

// Handle returns C version of TypingSelectRequest and its finalizer func.
func (self *TypingSelectRequest) Handle() (result *C.ImGuiTypingSelectRequest, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TypingSelectRequest) C() (C.ImGuiTypingSelectRequest, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTypingSelectRequest creates TypingSelectRequest with its 0 value.
func NewEmptyTypingSelectRequest() *TypingSelectRequest {
	return &TypingSelectRequest{CData: new(C.ImGuiTypingSelectRequest)}
}

// NewTypingSelectRequestFromC creates TypingSelectRequest from its C pointer.
// SRC ~= *C.ImGuiTypingSelectRequest
func NewTypingSelectRequestFromC[SRC any](cvalue SRC) *TypingSelectRequest {
	return &TypingSelectRequest{CData: internal.ReinterpretCast[*C.ImGuiTypingSelectRequest](cvalue)}
}

type TypingSelectState struct {
	CData *C.ImGuiTypingSelectState
}

// Handle returns C version of TypingSelectState and its finalizer func.
func (self *TypingSelectState) Handle() (result *C.ImGuiTypingSelectState, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TypingSelectState) C() (C.ImGuiTypingSelectState, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTypingSelectState creates TypingSelectState with its 0 value.
func NewEmptyTypingSelectState() *TypingSelectState {
	return &TypingSelectState{CData: new(C.ImGuiTypingSelectState)}
}

// NewTypingSelectStateFromC creates TypingSelectState from its C pointer.
// SRC ~= *C.ImGuiTypingSelectState
func NewTypingSelectStateFromC[SRC any](cvalue SRC) *TypingSelectState {
	return &TypingSelectState{CData: internal.ReinterpretCast[*C.ImGuiTypingSelectState](cvalue)}
}

type Viewport struct {
	CData *C.ImGuiViewport
}

// Handle returns C version of Viewport and its finalizer func.
func (self *Viewport) Handle() (result *C.ImGuiViewport, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Viewport) C() (C.ImGuiViewport, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyViewport creates Viewport with its 0 value.
func NewEmptyViewport() *Viewport {
	return &Viewport{CData: new(C.ImGuiViewport)}
}

// NewViewportFromC creates Viewport from its C pointer.
// SRC ~= *C.ImGuiViewport
func NewViewportFromC[SRC any](cvalue SRC) *Viewport {
	return &Viewport{CData: internal.ReinterpretCast[*C.ImGuiViewport](cvalue)}
}

type ViewportP struct {
	CData *C.ImGuiViewportP
}

// Handle returns C version of ViewportP and its finalizer func.
func (self *ViewportP) Handle() (result *C.ImGuiViewportP, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self ViewportP) C() (C.ImGuiViewportP, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyViewportP creates ViewportP with its 0 value.
func NewEmptyViewportP() *ViewportP {
	return &ViewportP{CData: new(C.ImGuiViewportP)}
}

// NewViewportPFromC creates ViewportP from its C pointer.
// SRC ~= *C.ImGuiViewportP
func NewViewportPFromC[SRC any](cvalue SRC) *ViewportP {
	return &ViewportP{CData: internal.ReinterpretCast[*C.ImGuiViewportP](cvalue)}
}

type Window struct {
	CData *C.ImGuiWindow
}

// Handle returns C version of Window and its finalizer func.
func (self *Window) Handle() (result *C.ImGuiWindow, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Window) C() (C.ImGuiWindow, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyWindow creates Window with its 0 value.
func NewEmptyWindow() *Window {
	return &Window{CData: new(C.ImGuiWindow)}
}

// NewWindowFromC creates Window from its C pointer.
// SRC ~= *C.ImGuiWindow
func NewWindowFromC[SRC any](cvalue SRC) *Window {
	return &Window{CData: internal.ReinterpretCast[*C.ImGuiWindow](cvalue)}
}

type WindowClass struct {
	CData *C.ImGuiWindowClass
}

// Handle returns C version of WindowClass and its finalizer func.
func (self *WindowClass) Handle() (result *C.ImGuiWindowClass, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self WindowClass) C() (C.ImGuiWindowClass, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyWindowClass creates WindowClass with its 0 value.
func NewEmptyWindowClass() *WindowClass {
	return &WindowClass{CData: new(C.ImGuiWindowClass)}
}

// NewWindowClassFromC creates WindowClass from its C pointer.
// SRC ~= *C.ImGuiWindowClass
func NewWindowClassFromC[SRC any](cvalue SRC) *WindowClass {
	return &WindowClass{CData: internal.ReinterpretCast[*C.ImGuiWindowClass](cvalue)}
}

type WindowDockStyle struct {
	CData *C.ImGuiWindowDockStyle
}

// Handle returns C version of WindowDockStyle and its finalizer func.
func (self *WindowDockStyle) Handle() (result *C.ImGuiWindowDockStyle, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self WindowDockStyle) C() (C.ImGuiWindowDockStyle, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyWindowDockStyle creates WindowDockStyle with its 0 value.
func NewEmptyWindowDockStyle() *WindowDockStyle {
	return &WindowDockStyle{CData: new(C.ImGuiWindowDockStyle)}
}

// NewWindowDockStyleFromC creates WindowDockStyle from its C pointer.
// SRC ~= *C.ImGuiWindowDockStyle
func NewWindowDockStyleFromC[SRC any](cvalue SRC) *WindowDockStyle {
	return &WindowDockStyle{CData: internal.ReinterpretCast[*C.ImGuiWindowDockStyle](cvalue)}
}

type WindowSettings struct {
	CData *C.ImGuiWindowSettings
}

// Handle returns C version of WindowSettings and its finalizer func.
func (self *WindowSettings) Handle() (result *C.ImGuiWindowSettings, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self WindowSettings) C() (C.ImGuiWindowSettings, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyWindowSettings creates WindowSettings with its 0 value.
func NewEmptyWindowSettings() *WindowSettings {
	return &WindowSettings{CData: new(C.ImGuiWindowSettings)}
}

// NewWindowSettingsFromC creates WindowSettings from its C pointer.
// SRC ~= *C.ImGuiWindowSettings
func NewWindowSettingsFromC[SRC any](cvalue SRC) *WindowSettings {
	return &WindowSettings{CData: internal.ReinterpretCast[*C.ImGuiWindowSettings](cvalue)}
}

type WindowStackData struct {
	CData *C.ImGuiWindowStackData
}

// Handle returns C version of WindowStackData and its finalizer func.
func (self *WindowStackData) Handle() (result *C.ImGuiWindowStackData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self WindowStackData) C() (C.ImGuiWindowStackData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyWindowStackData creates WindowStackData with its 0 value.
func NewEmptyWindowStackData() *WindowStackData {
	return &WindowStackData{CData: new(C.ImGuiWindowStackData)}
}

// NewWindowStackDataFromC creates WindowStackData from its C pointer.
// SRC ~= *C.ImGuiWindowStackData
func NewWindowStackDataFromC[SRC any](cvalue SRC) *WindowStackData {
	return &WindowStackData{CData: internal.ReinterpretCast[*C.ImGuiWindowStackData](cvalue)}
}

type WindowTempData struct {
	CData *C.ImGuiWindowTempData
}

// Handle returns C version of WindowTempData and its finalizer func.
func (self *WindowTempData) Handle() (result *C.ImGuiWindowTempData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self WindowTempData) C() (C.ImGuiWindowTempData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyWindowTempData creates WindowTempData with its 0 value.
func NewEmptyWindowTempData() *WindowTempData {
	return &WindowTempData{CData: new(C.ImGuiWindowTempData)}
}

// NewWindowTempDataFromC creates WindowTempData from its C pointer.
// SRC ~= *C.ImGuiWindowTempData
func NewWindowTempDataFromC[SRC any](cvalue SRC) *WindowTempData {
	return &WindowTempData{CData: internal.ReinterpretCast[*C.ImGuiWindowTempData](cvalue)}
}

type PoolIdx int32

// Handle returns C version of PoolIdx and its finalizer func.
func (selfSrc *PoolIdx) Handle() (result *C.ImPoolIdx, fin func()) {
	self := (*int32)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.int, int32](self)
	return (*C.ImPoolIdx)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self PoolIdx) C() (C.ImPoolIdx, func()) {
	return (C.ImPoolIdx)(C.int(self)), func() {}
}

// NewPoolIdxFromC creates PoolIdx from its C pointer.
// SRC ~= *C.ImPoolIdx
func NewPoolIdxFromC[SRC any](cvalue SRC) *PoolIdx {
	return (*PoolIdx)((*int32)(internal.ReinterpretCast[*C.ImPoolIdx](cvalue)))
}

type TextureData struct {
	CData *C.ImTextureData
}

// Handle returns C version of TextureData and its finalizer func.
func (self *TextureData) Handle() (result *C.ImTextureData, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TextureData) C() (C.ImTextureData, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTextureData creates TextureData with its 0 value.
func NewEmptyTextureData() *TextureData {
	return &TextureData{CData: new(C.ImTextureData)}
}

// NewTextureDataFromC creates TextureData from its C pointer.
// SRC ~= *C.ImTextureData
func NewTextureDataFromC[SRC any](cvalue SRC) *TextureData {
	return &TextureData{CData: internal.ReinterpretCast[*C.ImTextureData](cvalue)}
}

type TextureID uint64

// Handle returns C version of TextureID and its finalizer func.
func (selfSrc *TextureID) Handle() (result *C.ImTextureID, fin func()) {
	self := (*uint64)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.ImU64, uint64](self)
	return (*C.ImTextureID)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self TextureID) C() (C.ImTextureID, func()) {
	return (C.ImTextureID)(C.ImU64(self)), func() {}
}

// NewTextureIDFromC creates TextureID from its C pointer.
// SRC ~= *C.ImTextureID
func NewTextureIDFromC[SRC any](cvalue SRC) *TextureID {
	return (*TextureID)((*uint64)(internal.ReinterpretCast[*C.ImTextureID](cvalue)))
}

type TextureRect struct {
	CData *C.ImTextureRect
}

// Handle returns C version of TextureRect and its finalizer func.
func (self *TextureRect) Handle() (result *C.ImTextureRect, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TextureRect) C() (C.ImTextureRect, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTextureRect creates TextureRect with its 0 value.
func NewEmptyTextureRect() *TextureRect {
	return &TextureRect{CData: new(C.ImTextureRect)}
}

// NewTextureRectFromC creates TextureRect from its C pointer.
// SRC ~= *C.ImTextureRect
func NewTextureRectFromC[SRC any](cvalue SRC) *TextureRect {
	return &TextureRect{CData: internal.ReinterpretCast[*C.ImTextureRect](cvalue)}
}

type TextureRef struct {
	CData *C.ImTextureRef
}

// Handle returns C version of TextureRef and its finalizer func.
func (self *TextureRef) Handle() (result *C.ImTextureRef, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self TextureRef) C() (C.ImTextureRef, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyTextureRef creates TextureRef with its 0 value.
func NewEmptyTextureRef() *TextureRef {
	return &TextureRef{CData: new(C.ImTextureRef)}
}

// NewTextureRefFromC creates TextureRef from its C pointer.
// SRC ~= *C.ImTextureRef
func NewTextureRefFromC[SRC any](cvalue SRC) *TextureRef {
	return &TextureRef{CData: internal.ReinterpretCast[*C.ImTextureRef](cvalue)}
}

type Vec1 struct {
	CData *C.ImVec1
}

// Handle returns C version of Vec1 and its finalizer func.
func (self *Vec1) Handle() (result *C.ImVec1, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Vec1) C() (C.ImVec1, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyVec1 creates Vec1 with its 0 value.
func NewEmptyVec1() *Vec1 {
	return &Vec1{CData: new(C.ImVec1)}
}

// NewVec1FromC creates Vec1 from its C pointer.
// SRC ~= *C.ImVec1
func NewVec1FromC[SRC any](cvalue SRC) *Vec1 {
	return &Vec1{CData: internal.ReinterpretCast[*C.ImVec1](cvalue)}
}

type Vec2i struct {
	CData *C.ImVec2i
}

// Handle returns C version of Vec2i and its finalizer func.
func (self *Vec2i) Handle() (result *C.ImVec2i, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self Vec2i) C() (C.ImVec2i, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptyVec2i creates Vec2i with its 0 value.
func NewEmptyVec2i() *Vec2i {
	return &Vec2i{CData: new(C.ImVec2i)}
}

// NewVec2iFromC creates Vec2i from its C pointer.
// SRC ~= *C.ImVec2i
func NewVec2iFromC[SRC any](cvalue SRC) *Vec2i {
	return &Vec2i{CData: internal.ReinterpretCast[*C.ImVec2i](cvalue)}
}

type Wchar16 uint16

// Handle returns C version of Wchar16 and its finalizer func.
func (selfSrc *Wchar16) Handle() (result *C.ImWchar16, fin func()) {
	self := (*uint16)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.ushort, uint16](self)
	return (*C.ImWchar16)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self Wchar16) C() (C.ImWchar16, func()) {
	return (C.ImWchar16)(C.ushort(self)), func() {}
}

// NewWchar16FromC creates Wchar16 from its C pointer.
// SRC ~= *C.ImWchar16
func NewWchar16FromC[SRC any](cvalue SRC) *Wchar16 {
	return (*Wchar16)((*uint16)(internal.ReinterpretCast[*C.ImWchar16](cvalue)))
}

type Wchar32 uint32

// Handle returns C version of Wchar32 and its finalizer func.
func (selfSrc *Wchar32) Handle() (result *C.ImWchar32, fin func()) {
	self := (*uint32)(selfSrc)
	selfArg, selfFin := internal.WrapNumberPtr[C.uint, uint32](self)
	return (*C.ImWchar32)(selfArg), func() { selfFin() }
}

// C is like Handle but returns plain type instead of pointer.
func (self Wchar32) C() (C.ImWchar32, func()) {
	return (C.ImWchar32)(C.uint(self)), func() {}
}

// NewWchar32FromC creates Wchar32 from its C pointer.
// SRC ~= *C.ImWchar32
func NewWchar32FromC[SRC any](cvalue SRC) *Wchar32 {
	return (*Wchar32)((*uint32)(internal.ReinterpretCast[*C.ImWchar32](cvalue)))
}

type STBTexteditState struct {
	CData *C.STB_TexteditState
}

// Handle returns C version of STBTexteditState and its finalizer func.
func (self *STBTexteditState) Handle() (result *C.STB_TexteditState, fin func()) {
	return self.CData, func() {}
}

// NewSTBTexteditStateFromC creates STBTexteditState from its C pointer.
// SRC ~= *C.STB_TexteditState
func NewSTBTexteditStateFromC[SRC any](cvalue SRC) *STBTexteditState {
	return &STBTexteditState{CData: internal.ReinterpretCast[*C.STB_TexteditState](cvalue)}
}

type stbrpcontextopaque struct {
	CData *C.stbrp_context_opaque
}

// Handle returns C version of stbrpcontextopaque and its finalizer func.
func (self *stbrpcontextopaque) Handle() (result *C.stbrp_context_opaque, fin func()) {
	return self.CData, func() {}
}

// C is like Handle but returns plain type instead of pointer.
func (self stbrpcontextopaque) C() (C.stbrp_context_opaque, func()) {
	result, fn := self.Handle()
	return *result, fn
}

// NewEmptystbrpcontextopaque creates stbrpcontextopaque with its 0 value.
func NewEmptystbrpcontextopaque() *stbrpcontextopaque {
	return &stbrpcontextopaque{CData: new(C.stbrp_context_opaque)}
}

// NewstbrpcontextopaqueFromC creates stbrpcontextopaque from its C pointer.
// SRC ~= *C.stbrp_context_opaque
func NewstbrpcontextopaqueFromC[SRC any](cvalue SRC) *stbrpcontextopaque {
	return &stbrpcontextopaque{CData: internal.ReinterpretCast[*C.stbrp_context_opaque](cvalue)}
}

type stbrpnode struct {
	CData *C.stbrp_node
}

// Handle returns C version of stbrpnode and its finalizer func.
func (self *stbrpnode) Handle() (result *C.stbrp_node, fin func()) {
	return self.CData, func() {}
}

// NewstbrpnodeFromC creates stbrpnode from its C pointer.
// SRC ~= *C.stbrp_node
func NewstbrpnodeFromC[SRC any](cvalue SRC) *stbrpnode {
	return &stbrpnode{CData: internal.ReinterpretCast[*C.stbrp_node](cvalue)}
}
