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

package implot

import (
	"unsafe"

	"github.com/AllenDang/cimgui-go/imgui"
	"github.com/AllenDang/cimgui-go/internal"
	"github.com/AllenDang/cimgui-go/utils/vectors"
)

// #include "structs_accessor.h"
// #include "wrapper.h"
// #include "../imgui/extra_types.h"
import "C"

func (self *AlignmentData) Begin() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAlignmentData_Begin(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg))

	selfFin()
}

func (self *AlignmentData) End() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAlignmentData_End(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg))

	selfFin()
}

func NewAlignmentData() *AlignmentData {
	return NewAlignmentDataFromC(C.ImPlotAlignmentData_ImPlotAlignmentData())
}

func (self *AlignmentData) Reset() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAlignmentData_Reset(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg))

	selfFin()
}

func (self *AlignmentData) Update(pad_a, pad_b, delta_a, delta_b *float32) {
	selfArg, selfFin := self.Handle()
	pad_aArg, pad_aFin := internal.WrapNumberPtr[C.float, float32](pad_a)
	pad_bArg, pad_bFin := internal.WrapNumberPtr[C.float, float32](pad_b)
	delta_aArg, delta_aFin := internal.WrapNumberPtr[C.float, float32](delta_a)
	delta_bArg, delta_bFin := internal.WrapNumberPtr[C.float, float32](delta_b)
	C.ImPlotAlignmentData_Update(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg), pad_aArg, pad_bArg, delta_aArg, delta_bArg)

	selfFin()
	pad_aFin()
	pad_bFin()
	delta_aFin()
	delta_bFin()
}

func (self *AlignmentData) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAlignmentData_destroy(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg))

	selfFin()
}

func (self *AnnotationCollection) Append(pos, off imgui.Vec2, bg, fg uint32, clamp bool, fmt string) {
	selfArg, selfFin := self.Handle()
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_ImPlotAnnotationCollection_Append(internal.ReinterpretCast[*C.ImPlotAnnotationCollection](selfArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), internal.ReinterpretCast[C.ImVec2](off.ToC()), C.ImU32(bg), C.ImU32(fg), C.bool(clamp), fmtArg)

	selfFin()
	fmtFin()
}

func (self *AnnotationCollection) Text(idx int32) string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImPlotAnnotationCollection_GetText(internal.ReinterpretCast[*C.ImPlotAnnotationCollection](selfArg), C.int(idx)))
}

func NewAnnotationCollection() *AnnotationCollection {
	return NewAnnotationCollectionFromC(C.ImPlotAnnotationCollection_ImPlotAnnotationCollection())
}

func (self *AnnotationCollection) Reset() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAnnotationCollection_Reset(internal.ReinterpretCast[*C.ImPlotAnnotationCollection](selfArg))

	selfFin()
}

func (self *AnnotationCollection) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAnnotationCollection_destroy(internal.ReinterpretCast[*C.ImPlotAnnotationCollection](selfArg))

	selfFin()
}

func NewAnnotation() *Annotation {
	return NewAnnotationFromC(C.ImPlotAnnotation_ImPlotAnnotation())
}

func (self *Annotation) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAnnotation_destroy(internal.ReinterpretCast[*C.ImPlotAnnotation](selfArg))

	selfFin()
}

func (self *Axis) ApplyFit(padding float32) {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_ApplyFit(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.float(padding))

	selfFin()
}

func (self *Axis) CanInitFit() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_CanInitFit(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) Constrain() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_Constrain(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	selfFin()
}

func (self *Axis) ExtendFit(v float64) {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_ExtendFit(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.double(v))

	selfFin()
}

func (self *Axis) ExtendFitWith(alt *Axis, v, v_alt float64) {
	selfArg, selfFin := self.Handle()
	altArg, altFin := alt.Handle()
	C.ImPlotAxis_ExtendFitWith(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), internal.ReinterpretCast[*C.ImPlotAxis](altArg), C.double(v), C.double(v_alt))

	selfFin()
	altFin()
}

func (self *Axis) Aspect() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.ImPlotAxis_GetAspect(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) HasGridLines() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_HasGridLines(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) HasLabel() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_HasLabel(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) HasMenus() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_HasMenus(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) HasTickLabels() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_HasTickLabels(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) HasTickMarks() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_HasTickMarks(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func NewAxis() *Axis {
	return NewAxisFromC(C.ImPlotAxis_ImPlotAxis())
}

func (self *Axis) IsAutoFitting() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsAutoFitting(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsForeground() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsForeground(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsInputLocked() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsInputLocked(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsInputLockedMax() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsInputLockedMax(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsInputLockedMin() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsInputLockedMin(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsInverted() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsInverted(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsLocked() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsLocked(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsLockedMax() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsLockedMax(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsLockedMin() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsLockedMin(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsOpposite() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsOpposite(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) IsPanLocked(increasing bool) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsPanLocked(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.bool(increasing)) == C.bool(true)
}

func (self *Axis) IsRangeLocked() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_IsRangeLocked(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) PixelSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.ImPlotAxis_PixelSize(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) PixelsToPlot(pix float32) float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.ImPlotAxis_PixelsToPlot(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.float(pix)))
}

func (self *Axis) PlotToPixels(plt float64) float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.ImPlotAxis_PlotToPixels(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.double(plt)))
}

func (self *Axis) PullLinks() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_PullLinks(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	selfFin()
}

func (self *Axis) PushLinks() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_PushLinks(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	selfFin()
}

func (self *Axis) Reset() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_Reset(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	selfFin()
}

func (self *Axis) SetAspect(unit_per_pix float64) {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_SetAspect(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.double(unit_per_pix))

	selfFin()
}

// SetMaxV parameter default value hint:
// force: false
func (self *Axis) SetMaxV(_max float64, force bool) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_SetMax(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.double(_max), C.bool(force)) == C.bool(true)
}

// SetMinV parameter default value hint:
// force: false
func (self *Axis) SetMinV(_min float64, force bool) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_SetMin(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.double(_min), C.bool(force)) == C.bool(true)
}

func (self *Axis) SetRangePlotRange(rangeArg Range) {
	selfArg, selfFin := self.Handle()
	rangeArgArg, rangeArgFin := rangeArg.C()
	C.ImPlotAxis_SetRange_PlotRange(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg))

	selfFin()
	rangeArgFin()
}

func (self *Axis) SetRangedouble(v1, v2 float64) {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_SetRange_double(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.double(v1), C.double(v2))

	selfFin()
}

func (self *Axis) UpdateTransformCache() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_UpdateTransformCache(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	selfFin()
}

func (self *Axis) WillRender() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotAxis_WillRender(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotAxis_destroy(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	selfFin()
}

func (self *ColormapData) Append(name string, keys *uint32, count int32, qual bool) int32 {
	selfArg, selfFin := self.Handle()
	nameArg, nameFin := internal.WrapString[C.char](name)
	keysArg, keysFin := internal.WrapNumberPtr[C.ImU32, uint32](keys)

	defer func() {
		selfFin()
		nameFin()
		keysFin()
	}()
	return int32(C.ImPlotColormapData_Append(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), nameArg, keysArg, C.int(count), C.bool(qual)))
}

func (self *ColormapData) Index(name string) Colormap {
	selfArg, selfFin := self.Handle()
	nameArg, nameFin := internal.WrapString[C.char](name)

	defer func() {
		selfFin()
		nameFin()
	}()
	return Colormap(C.ImPlotColormapData_GetIndex(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), nameArg))
}

func (self *ColormapData) KeyColor(cmap Colormap, idx int32) uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.ImPlotColormapData_GetKeyColor(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap), C.int(idx)))
}

func (self *ColormapData) KeyCount(cmap Colormap) int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImPlotColormapData_GetKeyCount(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap)))
}

func (self *ColormapData) Keys(cmap Colormap) *uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (*uint32)(C.ImPlotColormapData_GetKeys(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap)))
}

func (self *ColormapData) Name(cmap Colormap) string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImPlotColormapData_GetName(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap)))
}

func (self *ColormapData) Table(cmap Colormap) *uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (*uint32)(C.ImPlotColormapData_GetTable(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap)))
}

func (self *ColormapData) TableColor(cmap Colormap, idx int32) uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.ImPlotColormapData_GetTableColor(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap), C.int(idx)))
}

func (self *ColormapData) TableSize(cmap Colormap) int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImPlotColormapData_GetTableSize(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap)))
}

func NewColormapData() *ColormapData {
	return NewColormapDataFromC(C.ImPlotColormapData_ImPlotColormapData())
}

func (self *ColormapData) IsQual(cmap Colormap) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotColormapData_IsQual(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap)) == C.bool(true)
}

func (self *ColormapData) LerpTable(cmap Colormap, t float32) uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.ImPlotColormapData_LerpTable(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap), C.float(t)))
}

func (self *ColormapData) RebuildTables() {
	selfArg, selfFin := self.Handle()
	C.ImPlotColormapData_RebuildTables(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg))

	selfFin()
}

func (self *ColormapData) SetKeyColor(cmap Colormap, idx int32, value uint32) {
	selfArg, selfFin := self.Handle()
	C.ImPlotColormapData_SetKeyColor(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap), C.int(idx), C.ImU32(value))

	selfFin()
}

func (self *ColormapData) AppendTable(cmap Colormap) {
	selfArg, selfFin := self.Handle()
	C.ImPlotColormapData__AppendTable(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg), C.ImPlotColormap(cmap))

	selfFin()
}

func (self *ColormapData) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotColormapData_destroy(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg))

	selfFin()
}

func NewDateTimeSpecNil() *DateTimeSpec {
	return NewDateTimeSpecFromC(C.ImPlotDateTimeSpec_ImPlotDateTimeSpec_Nil())
}

// NewDateTimeSpecPlotDateFmt parameter default value hint:
// use_24_hr_clk: false
// use_iso_8601: false
func NewDateTimeSpecPlotDateFmt(date_fmt DateFmt, time_fmt TimeFmt, use_24_hr_clk, use_iso_8601 bool) *DateTimeSpec {
	return NewDateTimeSpecFromC(C.ImPlotDateTimeSpec_ImPlotDateTimeSpec_PlotDateFmt(C.ImPlotDateFmt(date_fmt), C.ImPlotTimeFmt(time_fmt), C.bool(use_24_hr_clk), C.bool(use_iso_8601)))
}

func (self *DateTimeSpec) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotDateTimeSpec_destroy(internal.ReinterpretCast[*C.ImPlotDateTimeSpec](selfArg))

	selfFin()
}

func NewInputMap() *InputMap {
	return NewInputMapFromC(C.ImPlotInputMap_ImPlotInputMap())
}

func (self *InputMap) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotInputMap_destroy(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg))

	selfFin()
}

func (self *ItemGroup) ItemByIndex(i int32) *Item {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewItemFromC(C.ImPlotItemGroup_GetItemByIndex(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg), C.int(i)))
}

func (self *ItemGroup) ItemCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImPlotItemGroup_GetItemCount(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg)))
}

func (self *ItemGroup) ItemID(label_id string) imgui.ID {
	selfArg, selfFin := self.Handle()
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		selfFin()
		label_idFin()
	}()
	return *imgui.NewIDFromC(func() *C.ImGuiID {
		result := C.ImPlotItemGroup_GetItemID(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg), label_idArg)
		return &result
	}())
}

func (self *ItemGroup) ItemIndex(item *Item) int32 {
	selfArg, selfFin := self.Handle()
	itemArg, itemFin := item.Handle()

	defer func() {
		selfFin()
		itemFin()
	}()
	return int32(C.ImPlotItemGroup_GetItemIndex(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg), internal.ReinterpretCast[*C.ImPlotItem](itemArg)))
}

func (self *ItemGroup) ItemByID(id imgui.ID) *Item {
	selfArg, selfFin := self.Handle()
	idArg, idFin := id.C()

	defer func() {
		selfFin()
		idFin()
	}()
	return NewItemFromC(C.ImPlotItemGroup_GetItem_ID(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg), internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func (self *ItemGroup) ItemStr(label_id string) *Item {
	selfArg, selfFin := self.Handle()
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		selfFin()
		label_idFin()
	}()
	return NewItemFromC(C.ImPlotItemGroup_GetItem_Str(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg), label_idArg))
}

func (self *ItemGroup) LegendCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImPlotItemGroup_GetLegendCount(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg)))
}

func (self *ItemGroup) LegendItem(i int32) *Item {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewItemFromC(C.ImPlotItemGroup_GetLegendItem(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg), C.int(i)))
}

func (self *ItemGroup) LegendLabel(i int32) string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImPlotItemGroup_GetLegendLabel(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg), C.int(i)))
}

func (self *ItemGroup) OrAddItem(id imgui.ID) *Item {
	selfArg, selfFin := self.Handle()
	idArg, idFin := id.C()

	defer func() {
		selfFin()
		idFin()
	}()
	return NewItemFromC(C.ImPlotItemGroup_GetOrAddItem(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg), internal.ReinterpretCast[C.ImGuiID](idArg)))
}

func NewItemGroup() *ItemGroup {
	return NewItemGroupFromC(C.ImPlotItemGroup_ImPlotItemGroup())
}

func (self *ItemGroup) Reset() {
	selfArg, selfFin := self.Handle()
	C.ImPlotItemGroup_Reset(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg))

	selfFin()
}

func (self *ItemGroup) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotItemGroup_destroy(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg))

	selfFin()
}

func NewItem() *Item {
	return NewItemFromC(C.ImPlotItem_ImPlotItem())
}

func (self *Item) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotItem_destroy(internal.ReinterpretCast[*C.ImPlotItem](selfArg))

	selfFin()
}

func NewLegend() *Legend {
	return NewLegendFromC(C.ImPlotLegend_ImPlotLegend())
}

func (self *Legend) Reset() {
	selfArg, selfFin := self.Handle()
	C.ImPlotLegend_Reset(internal.ReinterpretCast[*C.ImPlotLegend](selfArg))

	selfFin()
}

func (self *Legend) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotLegend_destroy(internal.ReinterpretCast[*C.ImPlotLegend](selfArg))

	selfFin()
}

func NewNextItemData() *NextItemData {
	return NewNextItemDataFromC(C.ImPlotNextItemData_ImPlotNextItemData())
}

func (self *NextItemData) Reset() {
	selfArg, selfFin := self.Handle()
	C.ImPlotNextItemData_Reset(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg))

	selfFin()
}

func (self *NextItemData) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotNextItemData_destroy(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg))

	selfFin()
}

func NewNextPlotData() *NextPlotData {
	return NewNextPlotDataFromC(C.ImPlotNextPlotData_ImPlotNextPlotData())
}

func (self *NextPlotData) Reset() {
	selfArg, selfFin := self.Handle()
	C.ImPlotNextPlotData_Reset(internal.ReinterpretCast[*C.ImPlotNextPlotData](selfArg))

	selfFin()
}

func (self *NextPlotData) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotNextPlotData_destroy(internal.ReinterpretCast[*C.ImPlotNextPlotData](selfArg))

	selfFin()
}

func (self *Plot) ClearTextBuffer() {
	selfArg, selfFin := self.Handle()
	C.ImPlotPlot_ClearTextBuffer(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))

	selfFin()
}

func (self *Plot) EnabledAxesX() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImPlotPlot_EnabledAxesX(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) EnabledAxesY() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImPlotPlot_EnabledAxesY(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) AxisLabel(axis Axis) string {
	selfArg, selfFin := self.Handle()
	axisArg, axisFin := axis.C()

	defer func() {
		selfFin()
		axisFin()
	}()
	return C.GoString(C.ImPlotPlot_GetAxisLabel(internal.ReinterpretCast[*C.ImPlotPlot](selfArg), internal.ReinterpretCast[C.ImPlotAxis](axisArg)))
}

func (self *Plot) Title() string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImPlotPlot_GetTitle(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) HasTitle() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotPlot_HasTitle(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func NewPlot() *Plot {
	return NewPlotFromC(C.ImPlotPlot_ImPlotPlot())
}

func (self *Plot) IsInputLocked() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotPlot_IsInputLocked(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self *Plot) SetAxisLabel(axis *Axis, label string) {
	selfArg, selfFin := self.Handle()
	axisArg, axisFin := axis.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.ImPlotPlot_SetAxisLabel(internal.ReinterpretCast[*C.ImPlotPlot](selfArg), internal.ReinterpretCast[*C.ImPlotAxis](axisArg), labelArg)

	selfFin()
	axisFin()
	labelFin()
}

func (self *Plot) SetTitle(title string) {
	selfArg, selfFin := self.Handle()
	titleArg, titleFin := internal.WrapString[C.char](title)
	C.ImPlotPlot_SetTitle(internal.ReinterpretCast[*C.ImPlotPlot](selfArg), titleArg)

	selfFin()
	titleFin()
}

func (self *Plot) XAxis(i int32) *Axis {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewAxisFromC(C.ImPlotPlot_XAxis_Nil(internal.ReinterpretCast[*C.ImPlotPlot](selfArg), C.int(i)))
}

func (self *Plot) XAxisconst(i int32) *Axis {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewAxisFromC(C.ImPlotPlot_XAxis__const(internal.ReinterpretCast[*C.ImPlotPlot](selfArg), C.int(i)))
}

func (self *Plot) YAxis(i int32) *Axis {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewAxisFromC(C.ImPlotPlot_YAxis_Nil(internal.ReinterpretCast[*C.ImPlotPlot](selfArg), C.int(i)))
}

func (self *Plot) YAxisconst(i int32) *Axis {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewAxisFromC(C.ImPlotPlot_YAxis__const(internal.ReinterpretCast[*C.ImPlotPlot](selfArg), C.int(i)))
}

func (self *Plot) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotPlot_destroy(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))

	selfFin()
}

func NewPointError(x, y, neg, pos float64) *PointError {
	return NewPointErrorFromC(C.ImPlotPointError_ImPlotPointError(C.double(x), C.double(y), C.double(neg), C.double(pos)))
}

func (self *PointError) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotPointError_destroy(internal.ReinterpretCast[*C.ImPlotPointError](selfArg))

	selfFin()
}

func (self *PlotPoint) Destroy() {
	selfArg, selfFin := internal.Wrap(self)
	C.ImPlotPoint_destroy(internal.ReinterpretCast[*C.ImPlotPoint](selfArg))

	selfFin()
}

func (self *Range) Clamp(value float64) float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.ImPlotRange_Clamp(internal.ReinterpretCast[*C.ImPlotRange](selfArg), C.double(value)))
}

func (self *Range) Contains(value float64) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotRange_Contains(internal.ReinterpretCast[*C.ImPlotRange](selfArg), C.double(value)) == C.bool(true)
}

func NewRangeNil() *Range {
	return NewRangeFromC(C.ImPlotRange_ImPlotRange_Nil())
}

func NewRangedouble(_min, _max float64) *Range {
	return NewRangeFromC(C.ImPlotRange_ImPlotRange_double(C.double(_min), C.double(_max)))
}

func (self *Range) Size() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.ImPlotRange_Size(internal.ReinterpretCast[*C.ImPlotRange](selfArg)))
}

func (self *Range) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotRange_destroy(internal.ReinterpretCast[*C.ImPlotRange](selfArg))

	selfFin()
}

func (self *Rect) ClampPlotPoInt(p PlotPoint) PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImPlotRect_Clamp_PlotPoInt(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), internal.ReinterpretCast[*C.ImPlotRect](selfArg), internal.ReinterpretCast[C.ImPlotPoint](p.ToC()))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Rect) Clampdouble(x, y float64) PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImPlotRect_Clamp_double(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), internal.ReinterpretCast[*C.ImPlotRect](selfArg), C.double(x), C.double(y))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Rect) ContainsPlotPoInt(p PlotPoint) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotRect_Contains_PlotPoInt(internal.ReinterpretCast[*C.ImPlotRect](selfArg), internal.ReinterpretCast[C.ImPlotPoint](p.ToC())) == C.bool(true)
}

func (self *Rect) Containsdouble(x, y float64) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.ImPlotRect_Contains_double(internal.ReinterpretCast[*C.ImPlotRect](selfArg), C.double(x), C.double(y)) == C.bool(true)
}

func NewRectNil() *Rect {
	return NewRectFromC(C.ImPlotRect_ImPlotRect_Nil())
}

func NewRectdouble(x_min, x_max, y_min, y_max float64) *Rect {
	return NewRectFromC(C.ImPlotRect_ImPlotRect_double(C.double(x_min), C.double(x_max), C.double(y_min), C.double(y_max)))
}

func (self *Rect) Max() PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImPlotRect_Max(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), internal.ReinterpretCast[*C.ImPlotRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Rect) Min() PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImPlotRect_Min(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), internal.ReinterpretCast[*C.ImPlotRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Rect) Size() PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	selfArg, selfFin := self.Handle()
	C.ImPlotRect_Size(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), internal.ReinterpretCast[*C.ImPlotRect](selfArg))

	pOutFin()
	selfFin()

	return *pOut
}

func (self *Rect) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotRect_destroy(internal.ReinterpretCast[*C.ImPlotRect](selfArg))

	selfFin()
}

func NewStyle() *Style {
	return NewStyleFromC(C.ImPlotStyle_ImPlotStyle())
}

func (self *Style) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotStyle_destroy(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))

	selfFin()
}

func NewSubplot() *Subplot {
	return NewSubplotFromC(C.ImPlotSubplot_ImPlotSubplot())
}

func (self *Subplot) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotSubplot_destroy(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg))

	selfFin()
}

func (self *TagCollection) Append(axis AxisEnum, value float64, bg, fg uint32, fmt string) {
	selfArg, selfFin := self.Handle()
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_ImPlotTagCollection_Append(internal.ReinterpretCast[*C.ImPlotTagCollection](selfArg), C.ImAxis(axis), C.double(value), C.ImU32(bg), C.ImU32(fg), fmtArg)

	selfFin()
	fmtFin()
}

func (self *TagCollection) Text(idx int32) string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImPlotTagCollection_GetText(internal.ReinterpretCast[*C.ImPlotTagCollection](selfArg), C.int(idx)))
}

func NewTagCollection() *TagCollection {
	return NewTagCollectionFromC(C.ImPlotTagCollection_ImPlotTagCollection())
}

func (self *TagCollection) Reset() {
	selfArg, selfFin := self.Handle()
	C.ImPlotTagCollection_Reset(internal.ReinterpretCast[*C.ImPlotTagCollection](selfArg))

	selfFin()
}

func (self *TagCollection) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotTagCollection_destroy(internal.ReinterpretCast[*C.ImPlotTagCollection](selfArg))

	selfFin()
}

func NewTick(value float64, major bool, level int32, show_label bool) *Tick {
	return NewTickFromC(C.ImPlotTick_ImPlotTick(C.double(value), C.bool(major), C.int(level), C.bool(show_label)))
}

func (self *Tick) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotTick_destroy(internal.ReinterpretCast[*C.ImPlotTick](selfArg))

	selfFin()
}

func (self *Ticker) AddTickPlotTick(tick Tick) *Tick {
	selfArg, selfFin := self.Handle()
	tickArg, tickFin := tick.C()

	defer func() {
		selfFin()
		tickFin()
	}()
	return NewTickFromC(C.ImPlotTicker_AddTick_PlotTick(internal.ReinterpretCast[*C.ImPlotTicker](selfArg), internal.ReinterpretCast[C.ImPlotTick](tickArg)))
}

func (self *Ticker) AddTickdoublePlotFormatter(value float64, major bool, level int32, show_label bool, formatter Formatter, data uintptr) *Tick {
	selfArg, selfFin := self.Handle()
	formatterArg, formatterFin := formatter.C()

	defer func() {
		selfFin()
		formatterFin()
	}()
	return NewTickFromC(C.wrap_ImPlotTicker_AddTick_doublePlotFormatter(internal.ReinterpretCast[*C.ImPlotTicker](selfArg), C.double(value), C.bool(major), C.int(level), C.bool(show_label), internal.ReinterpretCast[C.ImPlotFormatter](formatterArg), C.uintptr_t(data)))
}

func (self *Ticker) AddTickdoubleStr(value float64, major bool, level int32, show_label bool, label string) *Tick {
	selfArg, selfFin := self.Handle()
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		selfFin()
		labelFin()
	}()
	return NewTickFromC(C.ImPlotTicker_AddTick_doubleStr(internal.ReinterpretCast[*C.ImPlotTicker](selfArg), C.double(value), C.bool(major), C.int(level), C.bool(show_label), labelArg))
}

func (self *Ticker) TextInt(idx int32) string {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.GoString(C.ImPlotTicker_GetText_Int(internal.ReinterpretCast[*C.ImPlotTicker](selfArg), C.int(idx)))
}

func (self *Ticker) TextPlotTick(tick Tick) string {
	selfArg, selfFin := self.Handle()
	tickArg, tickFin := tick.C()

	defer func() {
		selfFin()
		tickFin()
	}()
	return C.GoString(C.ImPlotTicker_GetText_PlotTick(internal.ReinterpretCast[*C.ImPlotTicker](selfArg), internal.ReinterpretCast[C.ImPlotTick](tickArg)))
}

func NewTicker() *Ticker {
	return NewTickerFromC(C.ImPlotTicker_ImPlotTicker())
}

func (self *Ticker) OverrideSizeLate(size imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	C.ImPlotTicker_OverrideSizeLate(internal.ReinterpretCast[*C.ImPlotTicker](selfArg), internal.ReinterpretCast[C.ImVec2](size.ToC()))

	selfFin()
}

func (self *Ticker) Reset() {
	selfArg, selfFin := self.Handle()
	C.ImPlotTicker_Reset(internal.ReinterpretCast[*C.ImPlotTicker](selfArg))

	selfFin()
}

func (self *Ticker) TickCount() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.ImPlotTicker_TickCount(internal.ReinterpretCast[*C.ImPlotTicker](selfArg)))
}

func (self *Ticker) Destroy() {
	selfArg, selfFin := self.Handle()
	C.ImPlotTicker_destroy(internal.ReinterpretCast[*C.ImPlotTicker](selfArg))

	selfFin()
}

func TimeFromDouble(t float64) PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlotTime_FromDouble(internal.ReinterpretCast[*C.ImPlotTime](pOutArg), C.double(t))

	pOutFin()

	return *pOut
}

func (self *PlotTime) RollOver() {
	selfArg, selfFin := internal.Wrap(self)
	C.ImPlotTime_RollOver(internal.ReinterpretCast[*C.ImPlotTime](selfArg))

	selfFin()
}

func (self *PlotTime) ToDouble() float64 {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return float64(C.ImPlotTime_ToDouble(internal.ReinterpretCast[*C.ImPlotTime](selfArg)))
}

func (self *PlotTime) Destroy() {
	selfArg, selfFin := internal.Wrap(self)
	C.ImPlotTime_destroy(internal.ReinterpretCast[*C.ImPlotTime](selfArg))

	selfFin()
}

// AddColormapU32PtrV parameter default value hint:
// qual: true
func AddColormapU32PtrV(name string, cols *uint32, size int32, qual bool) Colormap {
	nameArg, nameFin := internal.WrapString[C.char](name)
	colsArg, colsFin := internal.WrapNumberPtr[C.ImU32, uint32](cols)

	defer func() {
		nameFin()
		colsFin()
	}()
	return Colormap(C.ImPlot_AddColormap_U32Ptr(nameArg, colsArg, C.int(size), C.bool(qual)))
}

// AddColormapVec4PtrV parameter default value hint:
// qual: true
func AddColormapVec4PtrV(name string, cols *imgui.Vec4, size int32, qual bool) Colormap {
	nameArg, nameFin := internal.WrapString[C.char](name)
	colsArg, colsFin := internal.Wrap(cols)

	defer func() {
		nameFin()
		colsFin()
	}()
	return Colormap(C.ImPlot_AddColormap_Vec4Ptr(nameArg, internal.ReinterpretCast[*C.ImVec4](colsArg), C.int(size), C.bool(qual)))
}

// AddTextCenteredV parameter default value hint:
func AddTextCenteredV(DrawList *imgui.DrawList, top_center imgui.Vec2, col uint32, text_begin string) {
	DrawListArg, DrawListFin := DrawList.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImPlot_AddTextCenteredV(internal.ReinterpretCast[*C.ImDrawList](DrawListArg), internal.ReinterpretCast[C.ImVec2](top_center.ToC()), C.ImU32(col), text_beginArg)

	DrawListFin()
	text_beginFin()
}

// AddTextVerticalV parameter default value hint:
func AddTextVerticalV(DrawList *imgui.DrawList, pos imgui.Vec2, col uint32, text_begin string) {
	DrawListArg, DrawListFin := DrawList.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImPlot_AddTextVerticalV(internal.ReinterpretCast[*C.ImDrawList](DrawListArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), text_beginArg)

	DrawListFin()
	text_beginFin()
}

func AddTime(t PlotTime, unit TimeUnit, count int32) PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_AddTime(internal.ReinterpretCast[*C.ImPlotTime](pOutArg), internal.ReinterpretCast[C.ImPlotTime](t.ToC()), C.ImPlotTimeUnit(unit), C.int(count))

	pOutFin()

	return *pOut
}

func AllAxesInputLocked(axes *Axis, count int32) bool {
	axesArg, axesFin := axes.Handle()

	defer func() {
		axesFin()
	}()
	return C.ImPlot_AllAxesInputLocked(internal.ReinterpretCast[*C.ImPlotAxis](axesArg), C.int(count)) == C.bool(true)
}

// AnnotationBoolV parameter default value hint:
// round: false
func AnnotationBoolV(x, y float64, col imgui.Vec4, pix_offset imgui.Vec2, clamp, round bool) {
	C.ImPlot_Annotation_Bool(C.double(x), C.double(y), internal.ReinterpretCast[C.ImVec4](col.ToC()), internal.ReinterpretCast[C.ImVec2](pix_offset.ToC()), C.bool(clamp), C.bool(round))
}

func AnnotationStr(x, y float64, col imgui.Vec4, pix_offset imgui.Vec2, clamp bool, fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_ImPlot_Annotation_Str(C.double(x), C.double(y), internal.ReinterpretCast[C.ImVec4](col.ToC()), internal.ReinterpretCast[C.ImVec2](pix_offset.ToC()), C.bool(clamp), fmtArg)

	fmtFin()
}

func AnyAxesHeld(axes *Axis, count int32) bool {
	axesArg, axesFin := axes.Handle()

	defer func() {
		axesFin()
	}()
	return C.ImPlot_AnyAxesHeld(internal.ReinterpretCast[*C.ImPlotAxis](axesArg), C.int(count)) == C.bool(true)
}

func AnyAxesHovered(axes *Axis, count int32) bool {
	axesArg, axesFin := axes.Handle()

	defer func() {
		axesFin()
	}()
	return C.ImPlot_AnyAxesHovered(internal.ReinterpretCast[*C.ImPlotAxis](axesArg), C.int(count)) == C.bool(true)
}

func AnyAxesInputLocked(axes *Axis, count int32) bool {
	axesArg, axesFin := axes.Handle()

	defer func() {
		axesFin()
	}()
	return C.ImPlot_AnyAxesInputLocked(internal.ReinterpretCast[*C.ImPlotAxis](axesArg), C.int(count)) == C.bool(true)
}

// BeginAlignedPlotsV parameter default value hint:
// vertical: true
func BeginAlignedPlotsV(group_id string, vertical bool) bool {
	group_idArg, group_idFin := internal.WrapString[C.char](group_id)

	defer func() {
		group_idFin()
	}()
	return C.ImPlot_BeginAlignedPlots(group_idArg, C.bool(vertical)) == C.bool(true)
}

// BeginDragDropSourceAxisV parameter default value hint:
// flags: 0
func BeginDragDropSourceAxisV(axis AxisEnum, flags imgui.DragDropFlags) bool {
	return C.ImPlot_BeginDragDropSourceAxis(C.ImAxis(axis), C.ImGuiDragDropFlags(flags)) == C.bool(true)
}

// BeginDragDropSourceItemV parameter default value hint:
// flags: 0
func BeginDragDropSourceItemV(label_id string, flags imgui.DragDropFlags) bool {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		label_idFin()
	}()
	return C.ImPlot_BeginDragDropSourceItem(label_idArg, C.ImGuiDragDropFlags(flags)) == C.bool(true)
}

// BeginDragDropSourcePlotV parameter default value hint:
// flags: 0
func BeginDragDropSourcePlotV(flags imgui.DragDropFlags) bool {
	return C.ImPlot_BeginDragDropSourcePlot(C.ImGuiDragDropFlags(flags)) == C.bool(true)
}

func BeginDragDropTargetAxis(axis AxisEnum) bool {
	return C.ImPlot_BeginDragDropTargetAxis(C.ImAxis(axis)) == C.bool(true)
}

func BeginDragDropTargetLegend() bool {
	return C.ImPlot_BeginDragDropTargetLegend() == C.bool(true)
}

func BeginDragDropTargetPlot() bool {
	return C.ImPlot_BeginDragDropTargetPlot() == C.bool(true)
}

// BeginItemV parameter default value hint:
// flags: 0
// recolor_from: -1
func BeginItemV(label_id string, flags ItemFlags, recolor_from Col) bool {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		label_idFin()
	}()
	return C.ImPlot_BeginItem(label_idArg, C.ImPlotItemFlags(flags), C.ImPlotCol(recolor_from)) == C.bool(true)
}

// BeginLegendPopupV parameter default value hint:
// mouse_button: 1
func BeginLegendPopupV(label_id string, mouse_button imgui.MouseButton) bool {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		label_idFin()
	}()
	return C.ImPlot_BeginLegendPopup(label_idArg, C.ImGuiMouseButton(mouse_button)) == C.bool(true)
}

// BeginPlotV parameter default value hint:
// size: ImVec2(-1,0)
// flags: 0
func BeginPlotV(title_id string, size imgui.Vec2, flags Flags) bool {
	title_idArg, title_idFin := internal.WrapString[C.char](title_id)

	defer func() {
		title_idFin()
	}()
	return C.ImPlot_BeginPlot(title_idArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImPlotFlags(flags)) == C.bool(true)
}

// BeginSubplotsV parameter default value hint:
// flags: 0
// row_ratios: nullptr
// col_ratios: nullptr
func BeginSubplotsV(title_id string, rows, cols int32, size imgui.Vec2, flags SubplotFlags, row_ratios, col_ratios *float32) bool {
	title_idArg, title_idFin := internal.WrapString[C.char](title_id)
	row_ratiosArg, row_ratiosFin := internal.WrapNumberPtr[C.float, float32](row_ratios)
	col_ratiosArg, col_ratiosFin := internal.WrapNumberPtr[C.float, float32](col_ratios)

	defer func() {
		title_idFin()
		row_ratiosFin()
		col_ratiosFin()
	}()
	return C.ImPlot_BeginSubplots(title_idArg, C.int(rows), C.int(cols), internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImPlotSubplotFlags(flags), row_ratiosArg, col_ratiosArg) == C.bool(true)
}

// BustColorCacheV parameter default value hint:
// plot_title_id: nullptr
func BustColorCacheV(plot_title_id string) {
	plot_title_idArg, plot_title_idFin := internal.WrapString[C.char](plot_title_id)
	C.ImPlot_BustColorCache(plot_title_idArg)

	plot_title_idFin()
}

func BustItemCache() {
	C.ImPlot_BustItemCache()
}

func BustPlotCache() {
	C.ImPlot_BustPlotCache()
}

func CalcHoverColor(col uint32) uint32 {
	return (uint32)(C.ImPlot_CalcHoverColor(C.ImU32(col)))
}

func CalcLegendSize(items *ItemGroup, pad, spacing imgui.Vec2, vertical bool) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	itemsArg, itemsFin := items.Handle()
	C.ImPlot_CalcLegendSize(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[*C.ImPlotItemGroup](itemsArg), internal.ReinterpretCast[C.ImVec2](pad.ToC()), internal.ReinterpretCast[C.ImVec2](spacing.ToC()), C.bool(vertical))

	pOutFin()
	itemsFin()

	return *pOut
}

func CalcTextColorU32(bg uint32) uint32 {
	return (uint32)(C.ImPlot_CalcTextColor_U32(C.ImU32(bg)))
}

func CalcTextColorVec4(bg imgui.Vec4) uint32 {
	return (uint32)(C.ImPlot_CalcTextColor_Vec4(internal.ReinterpretCast[C.ImVec4](bg.ToC())))
}

func CalcTextSizeVertical(text string) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	textArg, textFin := internal.WrapString[C.char](text)
	C.ImPlot_CalcTextSizeVertical(internal.ReinterpretCast[*C.ImVec2](pOutArg), textArg)

	pOutFin()
	textFin()

	return *pOut
}

func CalculateBinsFloatPtr(values *float32, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_FloatPtr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CalculateBinsS16Ptr(values *int16, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_S16Ptr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CalculateBinsS32Ptr(values *int32, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_S32Ptr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CalculateBinsS64Ptr(values *int64, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_S64Ptr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CalculateBinsS8Ptr(values *int8, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_S8Ptr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CalculateBinsU16Ptr(values *uint16, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_U16Ptr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CalculateBinsU32Ptr(values *uint32, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_U32Ptr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CalculateBinsU64Ptr(values *uint64, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_U64Ptr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CalculateBinsU8Ptr(values *byte, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_U8Ptr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CalculateBinsdoublePtr(values *float64, count int32, meth Bin, rangeArg Range, bins_out *int32, width_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	rangeArgArg, rangeArgFin := rangeArg.C()
	bins_outArg, bins_outFin := internal.WrapNumberPtr[C.int, int32](bins_out)
	width_outArg, width_outFin := internal.WrapNumberPtr[C.double, float64](width_out)
	C.ImPlot_CalculateBins_doublePtr(valuesArg, C.int(count), C.ImPlotBin(meth), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), bins_outArg, width_outArg)

	valuesFin()
	rangeArgFin()
	bins_outFin()
	width_outFin()
}

func CancelPlotSelection() {
	C.ImPlot_CancelPlotSelection()
}

func CeilTime(t PlotTime, unit TimeUnit) PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_CeilTime(internal.ReinterpretCast[*C.ImPlotTime](pOutArg), internal.ReinterpretCast[C.ImPlotTime](t.ToC()), C.ImPlotTimeUnit(unit))

	pOutFin()

	return *pOut
}

func ClampLabelPos(pos, size, Min, Max imgui.Vec2) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_ClampLabelPos(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), internal.ReinterpretCast[C.ImVec2](size.ToC()), internal.ReinterpretCast[C.ImVec2](Min.ToC()), internal.ReinterpretCast[C.ImVec2](Max.ToC()))

	pOutFin()

	return *pOut
}

func ClampLegendRect(legend_rect *imgui.Rect, outer_rect imgui.Rect, pad imgui.Vec2) bool {
	legend_rectArg, legend_rectFin := internal.Wrap(legend_rect)

	defer func() {
		legend_rectFin()
	}()
	return C.ImPlot_ClampLegendRect(internal.ReinterpretCast[*C.ImRect](legend_rectArg), internal.ReinterpretCast[C.ImRect](outer_rect.ToC()), internal.ReinterpretCast[C.ImVec2](pad.ToC())) == C.bool(true)
}

// ColormapButtonV parameter default value hint:
// size: ImVec2(0,0)
// cmap: -1
func ColormapButtonV(label string, size imgui.Vec2, cmap Colormap) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.ImPlot_ColormapButton(labelArg, internal.ReinterpretCast[C.ImVec2](size.ToC()), C.ImPlotColormap(cmap)) == C.bool(true)
}

func ColormapIcon(cmap Colormap) {
	C.ImPlot_ColormapIcon(C.ImPlotColormap(cmap))
}

// ColormapScaleV parameter default value hint:
// size: ImVec2(0,0)
// format: "%g"
// flags: 0
// cmap: -1
func ColormapScaleV(label string, scale_min, scale_max float64, size imgui.Vec2, format string, flags ColormapScaleFlags, cmap Colormap) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	formatArg, formatFin := internal.WrapString[C.char](format)
	C.ImPlot_ColormapScale(labelArg, C.double(scale_min), C.double(scale_max), internal.ReinterpretCast[C.ImVec2](size.ToC()), formatArg, C.ImPlotColormapScaleFlags(flags), C.ImPlotColormap(cmap))

	labelFin()
	formatFin()
}

// ColormapSliderV parameter default value hint:
// out: nullptr
// format: ""
// cmap: -1
func ColormapSliderV(label string, t *float32, out *imgui.Vec4, format string, cmap Colormap) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	tArg, tFin := internal.WrapNumberPtr[C.float, float32](t)
	outArg, outFin := internal.Wrap(out)
	formatArg, formatFin := internal.WrapString[C.char](format)

	defer func() {
		labelFin()
		tFin()
		outFin()
		formatFin()
	}()
	return C.ImPlot_ColormapSlider(labelArg, tArg, internal.ReinterpretCast[*C.ImVec4](outArg), formatArg, C.ImPlotColormap(cmap)) == C.bool(true)
}

func CombineDateTime(date_part, time_part PlotTime) PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_CombineDateTime(internal.ReinterpretCast[*C.ImPlotTime](pOutArg), internal.ReinterpretCast[C.ImPlotTime](date_part.ToC()), internal.ReinterpretCast[C.ImPlotTime](time_part.ToC()))

	pOutFin()

	return *pOut
}

func CreateContext() *Context {
	return NewContextFromC(C.ImPlot_CreateContext())
}

// DestroyContextV parameter default value hint:
// ctx: nullptr
func DestroyContextV(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.ImPlot_DestroyContext(internal.ReinterpretCast[*C.ImPlotContext](ctxArg))

	ctxFin()
}

// DragLineXV parameter default value hint:
// thickness: 1
// flags: 0
// out_clicked: nullptr
// out_hovered: nullptr
// held: nullptr
func DragLineXV(id int32, x *float64, col imgui.Vec4, thickness float32, flags DragToolFlags, out_clicked, out_hovered, held *bool) bool {
	xArg, xFin := internal.WrapNumberPtr[C.double, float64](x)
	out_clickedArg, out_clickedFin := internal.WrapNumberPtr[C.bool, bool](out_clicked)
	out_hoveredArg, out_hoveredFin := internal.WrapNumberPtr[C.bool, bool](out_hovered)
	heldArg, heldFin := internal.WrapNumberPtr[C.bool, bool](held)

	defer func() {
		xFin()
		out_clickedFin()
		out_hoveredFin()
		heldFin()
	}()
	return C.ImPlot_DragLineX(C.int(id), xArg, internal.ReinterpretCast[C.ImVec4](col.ToC()), C.float(thickness), C.ImPlotDragToolFlags(flags), out_clickedArg, out_hoveredArg, heldArg) == C.bool(true)
}

// DragLineYV parameter default value hint:
// thickness: 1
// flags: 0
// out_clicked: nullptr
// out_hovered: nullptr
// held: nullptr
func DragLineYV(id int32, y *float64, col imgui.Vec4, thickness float32, flags DragToolFlags, out_clicked, out_hovered, held *bool) bool {
	yArg, yFin := internal.WrapNumberPtr[C.double, float64](y)
	out_clickedArg, out_clickedFin := internal.WrapNumberPtr[C.bool, bool](out_clicked)
	out_hoveredArg, out_hoveredFin := internal.WrapNumberPtr[C.bool, bool](out_hovered)
	heldArg, heldFin := internal.WrapNumberPtr[C.bool, bool](held)

	defer func() {
		yFin()
		out_clickedFin()
		out_hoveredFin()
		heldFin()
	}()
	return C.ImPlot_DragLineY(C.int(id), yArg, internal.ReinterpretCast[C.ImVec4](col.ToC()), C.float(thickness), C.ImPlotDragToolFlags(flags), out_clickedArg, out_hoveredArg, heldArg) == C.bool(true)
}

// DragPointV parameter default value hint:
// size: 4
// flags: 0
// out_clicked: nullptr
// out_hovered: nullptr
// held: nullptr
func DragPointV(id int32, x, y *float64, col imgui.Vec4, size float32, flags DragToolFlags, out_clicked, out_hovered, held *bool) bool {
	xArg, xFin := internal.WrapNumberPtr[C.double, float64](x)
	yArg, yFin := internal.WrapNumberPtr[C.double, float64](y)
	out_clickedArg, out_clickedFin := internal.WrapNumberPtr[C.bool, bool](out_clicked)
	out_hoveredArg, out_hoveredFin := internal.WrapNumberPtr[C.bool, bool](out_hovered)
	heldArg, heldFin := internal.WrapNumberPtr[C.bool, bool](held)

	defer func() {
		xFin()
		yFin()
		out_clickedFin()
		out_hoveredFin()
		heldFin()
	}()
	return C.ImPlot_DragPoint(C.int(id), xArg, yArg, internal.ReinterpretCast[C.ImVec4](col.ToC()), C.float(size), C.ImPlotDragToolFlags(flags), out_clickedArg, out_hoveredArg, heldArg) == C.bool(true)
}

// DragRectV parameter default value hint:
// flags: 0
// out_clicked: nullptr
// out_hovered: nullptr
// held: nullptr
func DragRectV(id int32, x1, y1, x2, y2 *float64, col imgui.Vec4, flags DragToolFlags, out_clicked, out_hovered, held *bool) bool {
	x1Arg, x1Fin := internal.WrapNumberPtr[C.double, float64](x1)
	y1Arg, y1Fin := internal.WrapNumberPtr[C.double, float64](y1)
	x2Arg, x2Fin := internal.WrapNumberPtr[C.double, float64](x2)
	y2Arg, y2Fin := internal.WrapNumberPtr[C.double, float64](y2)
	out_clickedArg, out_clickedFin := internal.WrapNumberPtr[C.bool, bool](out_clicked)
	out_hoveredArg, out_hoveredFin := internal.WrapNumberPtr[C.bool, bool](out_hovered)
	heldArg, heldFin := internal.WrapNumberPtr[C.bool, bool](held)

	defer func() {
		x1Fin()
		y1Fin()
		x2Fin()
		y2Fin()
		out_clickedFin()
		out_hoveredFin()
		heldFin()
	}()
	return C.ImPlot_DragRect(C.int(id), x1Arg, y1Arg, x2Arg, y2Arg, internal.ReinterpretCast[C.ImVec4](col.ToC()), C.ImPlotDragToolFlags(flags), out_clickedArg, out_hoveredArg, heldArg) == C.bool(true)
}

func EndAlignedPlots() {
	C.ImPlot_EndAlignedPlots()
}

func EndDragDropSource() {
	C.ImPlot_EndDragDropSource()
}

func EndDragDropTarget() {
	C.ImPlot_EndDragDropTarget()
}

func EndItem() {
	C.ImPlot_EndItem()
}

func EndLegendPopup() {
	C.ImPlot_EndLegendPopup()
}

func EndPlot() {
	C.ImPlot_EndPlot()
}

func EndSubplots() {
	C.ImPlot_EndSubplots()
}

func FitPoint(p PlotPoint) {
	C.ImPlot_FitPoint(internal.ReinterpretCast[C.ImPlotPoint](p.ToC()))
}

func FitPointX(x float64) {
	C.ImPlot_FitPointX(C.double(x))
}

func FitPointY(y float64) {
	C.ImPlot_FitPointY(C.double(y))
}

func FitThisFrame() bool {
	return C.ImPlot_FitThisFrame() == C.bool(true)
}

func FloorTime(t PlotTime, unit TimeUnit) PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_FloorTime(internal.ReinterpretCast[*C.ImPlotTime](pOutArg), internal.ReinterpretCast[C.ImPlotTime](t.ToC()), C.ImPlotTimeUnit(unit))

	pOutFin()

	return *pOut
}

func FormatDate(t PlotTime, buffer string, size int32, fmt DateFmt, use_iso_8601 bool) int32 {
	bufferArg, bufferFin := internal.WrapString[C.char](buffer)

	defer func() {
		bufferFin()
	}()
	return int32(C.ImPlot_FormatDate(internal.ReinterpretCast[C.ImPlotTime](t.ToC()), bufferArg, C.int(size), C.ImPlotDateFmt(fmt), C.bool(use_iso_8601)))
}

func FormatDateTime(t PlotTime, buffer string, size int32, fmt DateTimeSpec) int32 {
	bufferArg, bufferFin := internal.WrapString[C.char](buffer)
	fmtArg, fmtFin := fmt.C()

	defer func() {
		bufferFin()
		fmtFin()
	}()
	return int32(C.ImPlot_FormatDateTime(internal.ReinterpretCast[C.ImPlotTime](t.ToC()), bufferArg, C.int(size), internal.ReinterpretCast[C.ImPlotDateTimeSpec](fmtArg)))
}

func FormatTime(t PlotTime, buffer string, size int32, fmt TimeFmt, use_24_hr_clk bool) int32 {
	bufferArg, bufferFin := internal.WrapString[C.char](buffer)

	defer func() {
		bufferFin()
	}()
	return int32(C.ImPlot_FormatTime(internal.ReinterpretCast[C.ImPlotTime](t.ToC()), bufferArg, C.int(size), C.ImPlotTimeFmt(fmt), C.bool(use_24_hr_clk)))
}

func FormatterDefault(value float64, buff string, size int32, data uintptr) int32 {
	buffArg, buffFin := internal.WrapString[C.char](buff)

	defer func() {
		buffFin()
	}()
	return int32(C.wrap_ImPlot_Formatter_Default(C.double(value), buffArg, C.int(size), C.uintptr_t(data)))
}

func FormatterLogit(value float64, buff string, size int32, noname1 uintptr) int32 {
	buffArg, buffFin := internal.WrapString[C.char](buff)

	defer func() {
		buffFin()
	}()
	return int32(C.wrap_ImPlot_Formatter_Logit(C.double(value), buffArg, C.int(size), C.uintptr_t(noname1)))
}

func FormatterTime(noname1 float64, buff string, size int32, data uintptr) int32 {
	buffArg, buffFin := internal.WrapString[C.char](buff)

	defer func() {
		buffFin()
	}()
	return int32(C.wrap_ImPlot_Formatter_Time(C.double(noname1), buffArg, C.int(size), C.uintptr_t(data)))
}

func GetAutoColor(idx Col) imgui.Vec4 {
	pOut := new(imgui.Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_GetAutoColor(internal.ReinterpretCast[*C.ImVec4](pOutArg), C.ImPlotCol(idx))

	pOutFin()

	return *pOut
}

// GetColormapColorV parameter default value hint:
// cmap: -1
func GetColormapColorV(idx int32, cmap Colormap) imgui.Vec4 {
	pOut := new(imgui.Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_GetColormapColor(internal.ReinterpretCast[*C.ImVec4](pOutArg), C.int(idx), C.ImPlotColormap(cmap))

	pOutFin()

	return *pOut
}

func GetColormapColorU32(idx int32, cmap Colormap) uint32 {
	return (uint32)(C.ImPlot_GetColormapColorU32(C.int(idx), C.ImPlotColormap(cmap)))
}

func GetColormapCount() int32 {
	return int32(C.ImPlot_GetColormapCount())
}

func GetColormapIndex(name string) Colormap {
	nameArg, nameFin := internal.WrapString[C.char](name)

	defer func() {
		nameFin()
	}()
	return Colormap(C.ImPlot_GetColormapIndex(nameArg))
}

func GetColormapName(cmap Colormap) string {
	return C.GoString(C.ImPlot_GetColormapName(C.ImPlotColormap(cmap)))
}

// GetColormapSizeV parameter default value hint:
// cmap: -1
func GetColormapSizeV(cmap Colormap) int32 {
	return int32(C.ImPlot_GetColormapSize(C.ImPlotColormap(cmap)))
}

func GetCurrentContext() *Context {
	return NewContextFromC(C.ImPlot_GetCurrentContext())
}

func GetCurrentItem() *Item {
	return NewItemFromC(C.ImPlot_GetCurrentItem())
}

func GetCurrentPlot() *Plot {
	return NewPlotFromC(C.ImPlot_GetCurrentPlot())
}

func GetDaysInMonth(year, month int32) int32 {
	return int32(C.ImPlot_GetDaysInMonth(C.int(year), C.int(month)))
}

func GetInputMap() *InputMap {
	return NewInputMapFromC(C.ImPlot_GetInputMap())
}

func GetItem(label_id string) *Item {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		label_idFin()
	}()
	return NewItemFromC(C.ImPlot_GetItem(label_idArg))
}

func GetItemData() *NextItemData {
	return NewNextItemDataFromC(C.ImPlot_GetItemData())
}

func GetLastItemColor() imgui.Vec4 {
	pOut := new(imgui.Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_GetLastItemColor(internal.ReinterpretCast[*C.ImVec4](pOutArg))

	pOutFin()

	return *pOut
}

// GetLocationPosV parameter default value hint:
// pad: ImVec2(0,0)
func GetLocationPosV(outer_rect imgui.Rect, inner_size imgui.Vec2, location Location, pad imgui.Vec2) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_GetLocationPos(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImRect](outer_rect.ToC()), internal.ReinterpretCast[C.ImVec2](inner_size.ToC()), C.ImPlotLocation(location), internal.ReinterpretCast[C.ImVec2](pad.ToC()))

	pOutFin()

	return *pOut
}

func GetMarkerName(idx Marker) string {
	return C.GoString(C.ImPlot_GetMarkerName(C.ImPlotMarker(idx)))
}

func GetMonth(t PlotTime) int32 {
	return int32(C.ImPlot_GetMonth(internal.ReinterpretCast[C.ImPlotTime](t.ToC())))
}

func GetPlot(title string) *Plot {
	titleArg, titleFin := internal.WrapString[C.char](title)

	defer func() {
		titleFin()
	}()
	return NewPlotFromC(C.ImPlot_GetPlot(titleArg))
}

func GetPlotDrawList() *imgui.DrawList {
	return imgui.NewDrawListFromC(C.ImPlot_GetPlotDrawList())
}

// GetPlotLimitsV parameter default value hint:
// x_axis: -1
// y_axis: -1
func GetPlotLimitsV(x_axis, y_axis AxisEnum) Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := pOut.Handle()

	C.ImPlot_GetPlotLimits(internal.ReinterpretCast[*C.ImPlotRect](pOutArg), C.ImAxis(x_axis), C.ImAxis(y_axis))

	pOutFin()

	return *pOut
}

// GetPlotMousePosV parameter default value hint:
// x_axis: -1
// y_axis: -1
func GetPlotMousePosV(x_axis, y_axis AxisEnum) PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_GetPlotMousePos(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), C.ImAxis(x_axis), C.ImAxis(y_axis))

	pOutFin()

	return *pOut
}

func GetPlotPos() imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_GetPlotPos(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

// GetPlotSelectionV parameter default value hint:
// x_axis: -1
// y_axis: -1
func GetPlotSelectionV(x_axis, y_axis AxisEnum) Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := pOut.Handle()

	C.ImPlot_GetPlotSelection(internal.ReinterpretCast[*C.ImPlotRect](pOutArg), C.ImAxis(x_axis), C.ImAxis(y_axis))

	pOutFin()

	return *pOut
}

func GetPlotSize() imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_GetPlotSize(internal.ReinterpretCast[*C.ImVec2](pOutArg))

	pOutFin()

	return *pOut
}

func GetStyle() *Style {
	return NewStyleFromC(C.ImPlot_GetStyle())
}

func GetStyleColorName(idx Col) string {
	return C.GoString(C.ImPlot_GetStyleColorName(C.ImPlotCol(idx)))
}

func GetStyleColorU32(idx Col) uint32 {
	return (uint32)(C.ImPlot_GetStyleColorU32(C.ImPlotCol(idx)))
}

func GetStyleColorVec4(idx Col) imgui.Vec4 {
	pOut := new(imgui.Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_GetStyleColorVec4(internal.ReinterpretCast[*C.ImVec4](pOutArg), C.ImPlotCol(idx))

	pOutFin()

	return *pOut
}

func GetYear(t PlotTime) int32 {
	return int32(C.ImPlot_GetYear(internal.ReinterpretCast[C.ImPlotTime](t.ToC())))
}

// HideNextItemV parameter default value hint:
// hidden: true
// cond: ImPlotCond_Once
func HideNextItemV(hidden bool, cond Cond) {
	C.ImPlot_HideNextItem(C.bool(hidden), C.ImPlotCond(cond))
}

// ImAlmostEqualV parameter default value hint:
// ulp: 2
func ImAlmostEqualV(v1, v2 float64, ulp int32) bool {
	return C.ImPlot_ImAlmostEqual(C.double(v1), C.double(v2), C.int(ulp)) == C.bool(true)
}

func ImAlphaU32(col uint32, alpha float32) uint32 {
	return (uint32)(C.ImPlot_ImAlphaU32(C.ImU32(col), C.float(alpha)))
}

func ImAsinhFloat(x float32) float32 {
	return float32(C.ImPlot_ImAsinh_Float(C.float(x)))
}

func ImAsinhdouble(x float64) float64 {
	return float64(C.ImPlot_ImAsinh_double(C.double(x)))
}

func ImConstrainInf(val float64) float64 {
	return float64(C.ImPlot_ImConstrainInf(C.double(val)))
}

func ImConstrainLog(val float64) float64 {
	return float64(C.ImPlot_ImConstrainLog(C.double(val)))
}

func ImConstrainNan(val float64) float64 {
	return float64(C.ImPlot_ImConstrainNan(C.double(val)))
}

func ImConstrainTime(val float64) float64 {
	return float64(C.ImPlot_ImConstrainTime(C.double(val)))
}

func ImLerpU32(colors *uint32, size int32, t float32) uint32 {
	colorsArg, colorsFin := internal.WrapNumberPtr[C.ImU32, uint32](colors)

	defer func() {
		colorsFin()
	}()
	return (uint32)(C.ImPlot_ImLerpU32(colorsArg, C.int(size), C.float(t)))
}

func ImLog10Float(x float32) float32 {
	return float32(C.ImPlot_ImLog10_Float(C.float(x)))
}

func ImLog10double(x float64) float64 {
	return float64(C.ImPlot_ImLog10_double(C.double(x)))
}

func ImMaxArrayFloatPtr(values *float32, count int32) float32 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)

	defer func() {
		valuesFin()
	}()
	return float32(C.ImPlot_ImMaxArray_FloatPtr(valuesArg, C.int(count)))
}

func ImMaxArrayS16Ptr(values *int16, count int32) int16 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)

	defer func() {
		valuesFin()
	}()
	return (int16)(C.ImPlot_ImMaxArray_S16Ptr(valuesArg, C.int(count)))
}

func ImMaxArrayS32Ptr(values *int32, count int32) int {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)

	defer func() {
		valuesFin()
	}()
	return (int)(C.ImPlot_ImMaxArray_S32Ptr(valuesArg, C.int(count)))
}

func ImMaxArrayS64Ptr(values *int64, count int32) int64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)

	defer func() {
		valuesFin()
	}()
	return (int64)(C.ImPlot_ImMaxArray_S64Ptr(valuesArg, C.int(count)))
}

func ImMaxArrayS8Ptr(values *int8, count int32) int {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)

	defer func() {
		valuesFin()
	}()
	return (int)(C.ImPlot_ImMaxArray_S8Ptr(valuesArg, C.int(count)))
}

func ImMaxArrayU16Ptr(values *uint16, count int32) uint16 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)

	defer func() {
		valuesFin()
	}()
	return (uint16)(C.ImPlot_ImMaxArray_U16Ptr(valuesArg, C.int(count)))
}

func ImMaxArrayU32Ptr(values *uint32, count int32) uint32 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)

	defer func() {
		valuesFin()
	}()
	return (uint32)(C.ImPlot_ImMaxArray_U32Ptr(valuesArg, C.int(count)))
}

func ImMaxArrayU64Ptr(values *uint64, count int32) uint64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)

	defer func() {
		valuesFin()
	}()
	return (uint64)(C.ImPlot_ImMaxArray_U64Ptr(valuesArg, C.int(count)))
}

func ImMaxArrayU8Ptr(values *byte, count int32) byte {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)

	defer func() {
		valuesFin()
	}()
	return (byte)(C.ImPlot_ImMaxArray_U8Ptr(valuesArg, C.int(count)))
}

func ImMaxArraydoublePtr(values *float64, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMaxArray_doublePtr(valuesArg, C.int(count)))
}

func ImMeanFloatPtr(values *float32, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_FloatPtr(valuesArg, C.int(count)))
}

func ImMeanS16Ptr(values *int16, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_S16Ptr(valuesArg, C.int(count)))
}

func ImMeanS32Ptr(values *int32, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_S32Ptr(valuesArg, C.int(count)))
}

func ImMeanS64Ptr(values *int64, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_S64Ptr(valuesArg, C.int(count)))
}

func ImMeanS8Ptr(values *int8, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_S8Ptr(valuesArg, C.int(count)))
}

func ImMeanU16Ptr(values *uint16, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_U16Ptr(valuesArg, C.int(count)))
}

func ImMeanU32Ptr(values *uint32, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_U32Ptr(valuesArg, C.int(count)))
}

func ImMeanU64Ptr(values *uint64, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_U64Ptr(valuesArg, C.int(count)))
}

func ImMeanU8Ptr(values *byte, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_U8Ptr(valuesArg, C.int(count)))
}

func ImMeandoublePtr(values *float64, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMean_doublePtr(valuesArg, C.int(count)))
}

func ImMinArrayFloatPtr(values *float32, count int32) float32 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)

	defer func() {
		valuesFin()
	}()
	return float32(C.ImPlot_ImMinArray_FloatPtr(valuesArg, C.int(count)))
}

func ImMinArrayS16Ptr(values *int16, count int32) int16 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)

	defer func() {
		valuesFin()
	}()
	return (int16)(C.ImPlot_ImMinArray_S16Ptr(valuesArg, C.int(count)))
}

func ImMinArrayS32Ptr(values *int32, count int32) int {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)

	defer func() {
		valuesFin()
	}()
	return (int)(C.ImPlot_ImMinArray_S32Ptr(valuesArg, C.int(count)))
}

func ImMinArrayS64Ptr(values *int64, count int32) int64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)

	defer func() {
		valuesFin()
	}()
	return (int64)(C.ImPlot_ImMinArray_S64Ptr(valuesArg, C.int(count)))
}

func ImMinArrayS8Ptr(values *int8, count int32) int {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)

	defer func() {
		valuesFin()
	}()
	return (int)(C.ImPlot_ImMinArray_S8Ptr(valuesArg, C.int(count)))
}

func ImMinArrayU16Ptr(values *uint16, count int32) uint16 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)

	defer func() {
		valuesFin()
	}()
	return (uint16)(C.ImPlot_ImMinArray_U16Ptr(valuesArg, C.int(count)))
}

func ImMinArrayU32Ptr(values *uint32, count int32) uint32 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)

	defer func() {
		valuesFin()
	}()
	return (uint32)(C.ImPlot_ImMinArray_U32Ptr(valuesArg, C.int(count)))
}

func ImMinArrayU64Ptr(values *uint64, count int32) uint64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)

	defer func() {
		valuesFin()
	}()
	return (uint64)(C.ImPlot_ImMinArray_U64Ptr(valuesArg, C.int(count)))
}

func ImMinArrayU8Ptr(values *byte, count int32) byte {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)

	defer func() {
		valuesFin()
	}()
	return (byte)(C.ImPlot_ImMinArray_U8Ptr(valuesArg, C.int(count)))
}

func ImMinArraydoublePtr(values *float64, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImMinArray_doublePtr(valuesArg, C.int(count)))
}

func ImMinMaxArrayFloatPtr(values *float32, count int32, min_out, max_out *float32) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.float, float32](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.float, float32](max_out)
	C.ImPlot_ImMinMaxArray_FloatPtr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMinMaxArrayS16Ptr(values *int16, count int32, min_out, max_out *int16) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.ImS16, int16](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.ImS16, int16](max_out)
	C.ImPlot_ImMinMaxArray_S16Ptr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMinMaxArrayS32Ptr(values *int32, count int32, min_out, max_out *int32) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.ImS32, int32](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.ImS32, int32](max_out)
	C.ImPlot_ImMinMaxArray_S32Ptr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMinMaxArrayS64Ptr(values *int64, count int32, min_out, max_out *int64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.ImS64, int64](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.ImS64, int64](max_out)
	C.ImPlot_ImMinMaxArray_S64Ptr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMinMaxArrayS8Ptr(values *int8, count int32, min_out, max_out *int8) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.ImS8, int8](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.ImS8, int8](max_out)
	C.ImPlot_ImMinMaxArray_S8Ptr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMinMaxArrayU16Ptr(values *uint16, count int32, min_out, max_out *uint16) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.ImU16, uint16](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.ImU16, uint16](max_out)
	C.ImPlot_ImMinMaxArray_U16Ptr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMinMaxArrayU32Ptr(values *uint32, count int32, min_out, max_out *uint32) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.ImU32, uint32](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.ImU32, uint32](max_out)
	C.ImPlot_ImMinMaxArray_U32Ptr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMinMaxArrayU64Ptr(values *uint64, count int32, min_out, max_out *uint64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.ImU64, uint64](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.ImU64, uint64](max_out)
	C.ImPlot_ImMinMaxArray_U64Ptr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMinMaxArrayU8Ptr(values *byte, count int32, min_out, max_out *byte) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.ImU8, byte](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.ImU8, byte](max_out)
	C.ImPlot_ImMinMaxArray_U8Ptr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMinMaxArraydoublePtr(values *float64, count int32, min_out, max_out *float64) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	min_outArg, min_outFin := internal.WrapNumberPtr[C.double, float64](min_out)
	max_outArg, max_outFin := internal.WrapNumberPtr[C.double, float64](max_out)
	C.ImPlot_ImMinMaxArray_doublePtr(valuesArg, C.int(count), min_outArg, max_outArg)

	valuesFin()
	min_outFin()
	max_outFin()
}

func ImMixU32(a, b, s uint32) uint32 {
	return (uint32)(C.ImPlot_ImMixU32(C.ImU32(a), C.ImU32(b), C.ImU32(s)))
}

func ImNan(val float64) bool {
	return C.ImPlot_ImNan(C.double(val)) == C.bool(true)
}

func ImNanOrInf(val float64) bool {
	return C.ImPlot_ImNanOrInf(C.double(val)) == C.bool(true)
}

func ImOverlapsFloat(min_a, max_a, min_b, max_b float32) bool {
	return C.ImPlot_ImOverlaps_Float(C.float(min_a), C.float(max_a), C.float(min_b), C.float(max_b)) == C.bool(true)
}

func ImOverlapsS16(min_a, max_a, min_b, max_b int16) bool {
	return C.ImPlot_ImOverlaps_S16(C.ImS16(min_a), C.ImS16(max_a), C.ImS16(min_b), C.ImS16(max_b)) == C.bool(true)
}

func ImOverlapsS32(min_a, max_a, min_b, max_b int) bool {
	return C.ImPlot_ImOverlaps_S32(C.ImS32(min_a), C.ImS32(max_a), C.ImS32(min_b), C.ImS32(max_b)) == C.bool(true)
}

func ImOverlapsS64(min_a, max_a, min_b, max_b int64) bool {
	return C.ImPlot_ImOverlaps_S64(C.ImS64(min_a), C.ImS64(max_a), C.ImS64(min_b), C.ImS64(max_b)) == C.bool(true)
}

func ImOverlapsS8(min_a, max_a, min_b, max_b int) bool {
	return C.ImPlot_ImOverlaps_S8(C.ImS8(min_a), C.ImS8(max_a), C.ImS8(min_b), C.ImS8(max_b)) == C.bool(true)
}

func ImOverlapsU16(min_a, max_a, min_b, max_b uint16) bool {
	return C.ImPlot_ImOverlaps_U16(C.ImU16(min_a), C.ImU16(max_a), C.ImU16(min_b), C.ImU16(max_b)) == C.bool(true)
}

func ImOverlapsU32(min_a, max_a, min_b, max_b uint32) bool {
	return C.ImPlot_ImOverlaps_U32(C.ImU32(min_a), C.ImU32(max_a), C.ImU32(min_b), C.ImU32(max_b)) == C.bool(true)
}

func ImOverlapsU64(min_a, max_a, min_b, max_b uint64) bool {
	return C.ImPlot_ImOverlaps_U64(C.ImU64(min_a), C.ImU64(max_a), C.ImU64(min_b), C.ImU64(max_b)) == C.bool(true)
}

func ImOverlapsU8(min_a, max_a, min_b, max_b byte) bool {
	return C.ImPlot_ImOverlaps_U8(C.ImU8(min_a), C.ImU8(max_a), C.ImU8(min_b), C.ImU8(max_b)) == C.bool(true)
}

func ImOverlapsdouble(min_a, max_a, min_b, max_b float64) bool {
	return C.ImPlot_ImOverlaps_double(C.double(min_a), C.double(max_a), C.double(min_b), C.double(max_b)) == C.bool(true)
}

func ImPosMod(l, r int32) int32 {
	return int32(C.ImPlot_ImPosMod(C.int(l), C.int(r)))
}

func ImRemap01Float(x, x0, x1 float32) float32 {
	return float32(C.ImPlot_ImRemap01_Float(C.float(x), C.float(x0), C.float(x1)))
}

func ImRemap01S16(x, x0, x1 int16) int16 {
	return (int16)(C.ImPlot_ImRemap01_S16(C.ImS16(x), C.ImS16(x0), C.ImS16(x1)))
}

func ImRemap01S32(x, x0, x1 int) int {
	return (int)(C.ImPlot_ImRemap01_S32(C.ImS32(x), C.ImS32(x0), C.ImS32(x1)))
}

func ImRemap01S64(x, x0, x1 int64) int64 {
	return (int64)(C.ImPlot_ImRemap01_S64(C.ImS64(x), C.ImS64(x0), C.ImS64(x1)))
}

func ImRemap01S8(x, x0, x1 int) int {
	return (int)(C.ImPlot_ImRemap01_S8(C.ImS8(x), C.ImS8(x0), C.ImS8(x1)))
}

func ImRemap01U16(x, x0, x1 uint16) uint16 {
	return (uint16)(C.ImPlot_ImRemap01_U16(C.ImU16(x), C.ImU16(x0), C.ImU16(x1)))
}

func ImRemap01U32(x, x0, x1 uint32) uint32 {
	return (uint32)(C.ImPlot_ImRemap01_U32(C.ImU32(x), C.ImU32(x0), C.ImU32(x1)))
}

func ImRemap01U64(x, x0, x1 uint64) uint64 {
	return (uint64)(C.ImPlot_ImRemap01_U64(C.ImU64(x), C.ImU64(x0), C.ImU64(x1)))
}

func ImRemap01U8(x, x0, x1 byte) byte {
	return (byte)(C.ImPlot_ImRemap01_U8(C.ImU8(x), C.ImU8(x0), C.ImU8(x1)))
}

func ImRemap01double(x, x0, x1 float64) float64 {
	return float64(C.ImPlot_ImRemap01_double(C.double(x), C.double(x0), C.double(x1)))
}

func ImRemapFloat(x, x0, x1, y0, y1 float32) float32 {
	return float32(C.ImPlot_ImRemap_Float(C.float(x), C.float(x0), C.float(x1), C.float(y0), C.float(y1)))
}

func ImRemapS16(x, x0, x1, y0, y1 int16) int16 {
	return (int16)(C.ImPlot_ImRemap_S16(C.ImS16(x), C.ImS16(x0), C.ImS16(x1), C.ImS16(y0), C.ImS16(y1)))
}

func ImRemapS32(x, x0, x1, y0, y1 int) int {
	return (int)(C.ImPlot_ImRemap_S32(C.ImS32(x), C.ImS32(x0), C.ImS32(x1), C.ImS32(y0), C.ImS32(y1)))
}

func ImRemapS64(x, x0, x1, y0, y1 int64) int64 {
	return (int64)(C.ImPlot_ImRemap_S64(C.ImS64(x), C.ImS64(x0), C.ImS64(x1), C.ImS64(y0), C.ImS64(y1)))
}

func ImRemapS8(x, x0, x1, y0, y1 int) int {
	return (int)(C.ImPlot_ImRemap_S8(C.ImS8(x), C.ImS8(x0), C.ImS8(x1), C.ImS8(y0), C.ImS8(y1)))
}

func ImRemapU16(x, x0, x1, y0, y1 uint16) uint16 {
	return (uint16)(C.ImPlot_ImRemap_U16(C.ImU16(x), C.ImU16(x0), C.ImU16(x1), C.ImU16(y0), C.ImU16(y1)))
}

func ImRemapU32(x, x0, x1, y0, y1 uint32) uint32 {
	return (uint32)(C.ImPlot_ImRemap_U32(C.ImU32(x), C.ImU32(x0), C.ImU32(x1), C.ImU32(y0), C.ImU32(y1)))
}

func ImRemapU64(x, x0, x1, y0, y1 uint64) uint64 {
	return (uint64)(C.ImPlot_ImRemap_U64(C.ImU64(x), C.ImU64(x0), C.ImU64(x1), C.ImU64(y0), C.ImU64(y1)))
}

func ImRemapU8(x, x0, x1, y0, y1 byte) byte {
	return (byte)(C.ImPlot_ImRemap_U8(C.ImU8(x), C.ImU8(x0), C.ImU8(x1), C.ImU8(y0), C.ImU8(y1)))
}

func ImRemapdouble(x, x0, x1, y0, y1 float64) float64 {
	return float64(C.ImPlot_ImRemap_double(C.double(x), C.double(x0), C.double(x1), C.double(y0), C.double(y1)))
}

func ImSinhFloat(x float32) float32 {
	return float32(C.ImPlot_ImSinh_Float(C.float(x)))
}

func ImSinhdouble(x float64) float64 {
	return float64(C.ImPlot_ImSinh_double(C.double(x)))
}

func ImStdDevFloatPtr(values *float32, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_FloatPtr(valuesArg, C.int(count)))
}

func ImStdDevS16Ptr(values *int16, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_S16Ptr(valuesArg, C.int(count)))
}

func ImStdDevS32Ptr(values *int32, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_S32Ptr(valuesArg, C.int(count)))
}

func ImStdDevS64Ptr(values *int64, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_S64Ptr(valuesArg, C.int(count)))
}

func ImStdDevS8Ptr(values *int8, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_S8Ptr(valuesArg, C.int(count)))
}

func ImStdDevU16Ptr(values *uint16, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_U16Ptr(valuesArg, C.int(count)))
}

func ImStdDevU32Ptr(values *uint32, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_U32Ptr(valuesArg, C.int(count)))
}

func ImStdDevU64Ptr(values *uint64, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_U64Ptr(valuesArg, C.int(count)))
}

func ImStdDevU8Ptr(values *byte, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_U8Ptr(valuesArg, C.int(count)))
}

func ImStdDevdoublePtr(values *float64, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImStdDev_doublePtr(valuesArg, C.int(count)))
}

func ImSumFloatPtr(values *float32, count int32) float32 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)

	defer func() {
		valuesFin()
	}()
	return float32(C.ImPlot_ImSum_FloatPtr(valuesArg, C.int(count)))
}

func ImSumS16Ptr(values *int16, count int32) int16 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)

	defer func() {
		valuesFin()
	}()
	return (int16)(C.ImPlot_ImSum_S16Ptr(valuesArg, C.int(count)))
}

func ImSumS32Ptr(values *int32, count int32) int {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)

	defer func() {
		valuesFin()
	}()
	return (int)(C.ImPlot_ImSum_S32Ptr(valuesArg, C.int(count)))
}

func ImSumS64Ptr(values *int64, count int32) int64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)

	defer func() {
		valuesFin()
	}()
	return (int64)(C.ImPlot_ImSum_S64Ptr(valuesArg, C.int(count)))
}

func ImSumS8Ptr(values *int8, count int32) int {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)

	defer func() {
		valuesFin()
	}()
	return (int)(C.ImPlot_ImSum_S8Ptr(valuesArg, C.int(count)))
}

func ImSumU16Ptr(values *uint16, count int32) uint16 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)

	defer func() {
		valuesFin()
	}()
	return (uint16)(C.ImPlot_ImSum_U16Ptr(valuesArg, C.int(count)))
}

func ImSumU32Ptr(values *uint32, count int32) uint32 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)

	defer func() {
		valuesFin()
	}()
	return (uint32)(C.ImPlot_ImSum_U32Ptr(valuesArg, C.int(count)))
}

func ImSumU64Ptr(values *uint64, count int32) uint64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)

	defer func() {
		valuesFin()
	}()
	return (uint64)(C.ImPlot_ImSum_U64Ptr(valuesArg, C.int(count)))
}

func ImSumU8Ptr(values *byte, count int32) byte {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)

	defer func() {
		valuesFin()
	}()
	return (byte)(C.ImPlot_ImSum_U8Ptr(valuesArg, C.int(count)))
}

func ImSumdoublePtr(values *float64, count int32) float64 {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)

	defer func() {
		valuesFin()
	}()
	return float64(C.ImPlot_ImSum_doublePtr(valuesArg, C.int(count)))
}

func Initialize(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.ImPlot_Initialize(internal.ReinterpretCast[*C.ImPlotContext](ctxArg))

	ctxFin()
}

func Intersection(a1, a2, b1, b2 imgui.Vec2) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_Intersection(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImVec2](a1.ToC()), internal.ReinterpretCast[C.ImVec2](a2.ToC()), internal.ReinterpretCast[C.ImVec2](b1.ToC()), internal.ReinterpretCast[C.ImVec2](b2.ToC()))

	pOutFin()

	return *pOut
}

func IsAxisHovered(axis AxisEnum) bool {
	return C.ImPlot_IsAxisHovered(C.ImAxis(axis)) == C.bool(true)
}

func IsColorAutoPlotCol(idx Col) bool {
	return C.ImPlot_IsColorAuto_PlotCol(C.ImPlotCol(idx)) == C.bool(true)
}

func IsColorAutoVec4(col imgui.Vec4) bool {
	return C.ImPlot_IsColorAuto_Vec4(internal.ReinterpretCast[C.ImVec4](col.ToC())) == C.bool(true)
}

func IsLeapYear(year int32) bool {
	return C.ImPlot_IsLeapYear(C.int(year)) == C.bool(true)
}

func IsLegendEntryHovered(label_id string) bool {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		label_idFin()
	}()
	return C.ImPlot_IsLegendEntryHovered(label_idArg) == C.bool(true)
}

func IsPlotHovered() bool {
	return C.ImPlot_IsPlotHovered() == C.bool(true)
}

func IsPlotSelected() bool {
	return C.ImPlot_IsPlotSelected() == C.bool(true)
}

func IsSubplotsHovered() bool {
	return C.ImPlot_IsSubplotsHovered() == C.bool(true)
}

func ItemIconU32(col uint32) {
	C.ImPlot_ItemIcon_U32(C.ImU32(col))
}

func ItemIconVec4(col imgui.Vec4) {
	C.ImPlot_ItemIcon_Vec4(internal.ReinterpretCast[C.ImVec4](col.ToC()))
}

// LabelAxisValueV parameter default value hint:
// round: false
func LabelAxisValueV(axis Axis, value float64, buff string, size int32, round bool) {
	axisArg, axisFin := axis.C()
	buffArg, buffFin := internal.WrapString[C.char](buff)
	C.ImPlot_LabelAxisValue(internal.ReinterpretCast[C.ImPlotAxis](axisArg), C.double(value), buffArg, C.int(size), C.bool(round))

	axisFin()
	buffFin()
}

func LocatorDefault(ticker *Ticker, rangeArg Range, pixels float32, vertical bool, formatter Formatter, formatter_data uintptr) {
	tickerArg, tickerFin := ticker.Handle()
	rangeArgArg, rangeArgFin := rangeArg.C()
	formatterArg, formatterFin := formatter.C()
	C.wrap_ImPlot_Locator_Default(internal.ReinterpretCast[*C.ImPlotTicker](tickerArg), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.float(pixels), C.bool(vertical), internal.ReinterpretCast[C.ImPlotFormatter](formatterArg), C.uintptr_t(formatter_data))

	tickerFin()
	rangeArgFin()
	formatterFin()
}

func LocatorLog10(ticker *Ticker, rangeArg Range, pixels float32, vertical bool, formatter Formatter, formatter_data uintptr) {
	tickerArg, tickerFin := ticker.Handle()
	rangeArgArg, rangeArgFin := rangeArg.C()
	formatterArg, formatterFin := formatter.C()
	C.wrap_ImPlot_Locator_Log10(internal.ReinterpretCast[*C.ImPlotTicker](tickerArg), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.float(pixels), C.bool(vertical), internal.ReinterpretCast[C.ImPlotFormatter](formatterArg), C.uintptr_t(formatter_data))

	tickerFin()
	rangeArgFin()
	formatterFin()
}

func LocatorSymLog(ticker *Ticker, rangeArg Range, pixels float32, vertical bool, formatter Formatter, formatter_data uintptr) {
	tickerArg, tickerFin := ticker.Handle()
	rangeArgArg, rangeArgFin := rangeArg.C()
	formatterArg, formatterFin := formatter.C()
	C.wrap_ImPlot_Locator_SymLog(internal.ReinterpretCast[*C.ImPlotTicker](tickerArg), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.float(pixels), C.bool(vertical), internal.ReinterpretCast[C.ImPlotFormatter](formatterArg), C.uintptr_t(formatter_data))

	tickerFin()
	rangeArgFin()
	formatterFin()
}

func LocatorTime(ticker *Ticker, rangeArg Range, pixels float32, vertical bool, formatter Formatter, formatter_data uintptr) {
	tickerArg, tickerFin := ticker.Handle()
	rangeArgArg, rangeArgFin := rangeArg.C()
	formatterArg, formatterFin := formatter.C()
	C.wrap_ImPlot_Locator_Time(internal.ReinterpretCast[*C.ImPlotTicker](tickerArg), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.float(pixels), C.bool(vertical), internal.ReinterpretCast[C.ImPlotFormatter](formatterArg), C.uintptr_t(formatter_data))

	tickerFin()
	rangeArgFin()
	formatterFin()
}

// MakeTimeV parameter default value hint:
// month: 0
// day: 1
// hour: 0
// min: 0
// sec: 0
// us: 0
func MakeTimeV(year, month, day, hour, min, sec, us int32) PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_MakeTime(internal.ReinterpretCast[*C.ImPlotTime](pOutArg), C.int(year), C.int(month), C.int(day), C.int(hour), C.int(min), C.int(sec), C.int(us))

	pOutFin()

	return *pOut
}

// MapInputDefaultV parameter default value hint:
// dst: nullptr
func MapInputDefaultV(dst *InputMap) {
	dstArg, dstFin := dst.Handle()
	C.ImPlot_MapInputDefault(internal.ReinterpretCast[*C.ImPlotInputMap](dstArg))

	dstFin()
}

// MapInputReverseV parameter default value hint:
// dst: nullptr
func MapInputReverseV(dst *InputMap) {
	dstArg, dstFin := dst.Handle()
	C.ImPlot_MapInputReverse(internal.ReinterpretCast[*C.ImPlotInputMap](dstArg))

	dstFin()
}

func NextColormapColor() imgui.Vec4 {
	pOut := new(imgui.Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_NextColormapColor(internal.ReinterpretCast[*C.ImVec4](pOutArg))

	pOutFin()

	return *pOut
}

func NextColormapColorU32() uint32 {
	return (uint32)(C.ImPlot_NextColormapColorU32())
}

func NiceNum(x float64, round bool) float64 {
	return float64(C.ImPlot_NiceNum(C.double(x), C.bool(round)))
}

func Now() PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_Now(internal.ReinterpretCast[*C.ImPlotTime](pOutArg))

	pOutFin()

	return *pOut
}

func OrderOfMagnitude(val float64) int32 {
	return int32(C.ImPlot_OrderOfMagnitude(C.double(val)))
}

func OrderToPrecision(order int32) int32 {
	return int32(C.ImPlot_OrderToPrecision(C.int(order)))
}

// PixelsToPlotFloatV parameter default value hint:
// x_axis: -1
// y_axis: -1
func PixelsToPlotFloatV(x, y float32, x_axis, y_axis AxisEnum) PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_PixelsToPlot_Float(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), C.float(x), C.float(y), C.ImAxis(x_axis), C.ImAxis(y_axis))

	pOutFin()

	return *pOut
}

// PixelsToPlotVec2V parameter default value hint:
// x_axis: -1
// y_axis: -1
func PixelsToPlotVec2V(pix imgui.Vec2, x_axis, y_axis AxisEnum) PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_PixelsToPlot_Vec2(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), internal.ReinterpretCast[C.ImVec2](pix.ToC()), C.ImAxis(x_axis), C.ImAxis(y_axis))

	pOutFin()

	return *pOut
}

// PlotBarGroupsFloatPtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsFloatPtrV(label_ids []string, values *float32, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.ImPlot_PlotBarGroups_FloatPtr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarGroupsS16PtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsS16PtrV(label_ids []string, values *int16, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.ImPlot_PlotBarGroups_S16Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarGroupsS32PtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsS32PtrV(label_ids []string, values *int32, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.ImPlot_PlotBarGroups_S32Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarGroupsS64PtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsS64PtrV(label_ids []string, values *int64, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.ImPlot_PlotBarGroups_S64Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarGroupsS8PtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsS8PtrV(label_ids []string, values *int8, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.ImPlot_PlotBarGroups_S8Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarGroupsU16PtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsU16PtrV(label_ids []string, values *uint16, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.ImPlot_PlotBarGroups_U16Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarGroupsU32PtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsU32PtrV(label_ids []string, values *uint32, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.ImPlot_PlotBarGroups_U32Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarGroupsU64PtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsU64PtrV(label_ids []string, values *uint64, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.ImPlot_PlotBarGroups_U64Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarGroupsU8PtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsU8PtrV(label_ids []string, values *byte, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.ImPlot_PlotBarGroups_U8Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarGroupsdoublePtrV parameter default value hint:
// group_size: 0.67
// shift: 0
// flags: 0
func PlotBarGroupsdoublePtrV(label_ids []string, values *float64, item_count, group_count int32, group_size, shift float64, flags BarGroupsFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.ImPlot_PlotBarGroups_doublePtr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count), C.double(group_size), C.double(shift), C.ImPlotBarGroupsFlags(flags))

	label_idsFin()
	valuesFin()
}

// PlotBarsFloatPtrFloatPtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotBarsFloatPtrFloatPtrV(label_id string, xs, ys *float32, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.ImPlot_PlotBars_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotBarsFloatPtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotBarsFloatPtrIntV(label_id string, values *float32, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.ImPlot_PlotBars_FloatPtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsS16PtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotBarsS16PtrIntV(label_id string, values *int16, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.ImPlot_PlotBars_S16PtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsS16PtrS16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotBarsS16PtrS16PtrV(label_id string, xs, ys *int16, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.ImPlot_PlotBars_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotBarsS32PtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotBarsS32PtrIntV(label_id string, values *int32, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.ImPlot_PlotBars_S32PtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsS32PtrS32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotBarsS32PtrS32PtrV(label_id string, xs, ys *int32, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.ImPlot_PlotBars_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotBarsS64PtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotBarsS64PtrIntV(label_id string, values *int64, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.ImPlot_PlotBars_S64PtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsS64PtrS64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotBarsS64PtrS64PtrV(label_id string, xs, ys *int64, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.ImPlot_PlotBars_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotBarsS8PtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotBarsS8PtrIntV(label_id string, values *int8, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.ImPlot_PlotBars_S8PtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsS8PtrS8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotBarsS8PtrS8PtrV(label_id string, xs, ys *int8, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.ImPlot_PlotBars_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotBarsU16PtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotBarsU16PtrIntV(label_id string, values *uint16, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.ImPlot_PlotBars_U16PtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsU16PtrU16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotBarsU16PtrU16PtrV(label_id string, xs, ys *uint16, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.ImPlot_PlotBars_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotBarsU32PtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotBarsU32PtrIntV(label_id string, values *uint32, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.ImPlot_PlotBars_U32PtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsU32PtrU32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotBarsU32PtrU32PtrV(label_id string, xs, ys *uint32, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.ImPlot_PlotBars_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotBarsU64PtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotBarsU64PtrIntV(label_id string, values *uint64, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.ImPlot_PlotBars_U64PtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsU64PtrU64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotBarsU64PtrU64PtrV(label_id string, xs, ys *uint64, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.ImPlot_PlotBars_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotBarsU8PtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotBarsU8PtrIntV(label_id string, values *byte, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.ImPlot_PlotBars_U8PtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsU8PtrU8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotBarsU8PtrU8PtrV(label_id string, xs, ys *byte, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.ImPlot_PlotBars_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotBarsdoublePtrIntV parameter default value hint:
// bar_size: 0.67
// shift: 0
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotBarsdoublePtrIntV(label_id string, values *float64, count int32, bar_size, shift float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.ImPlot_PlotBars_doublePtrInt(label_idArg, valuesArg, C.int(count), C.double(bar_size), C.double(shift), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotBarsdoublePtrdoublePtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotBarsdoublePtrdoublePtrV(label_id string, xs, ys *float64, count int32, bar_size float64, flags BarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.ImPlot_PlotBars_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size), C.ImPlotBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitalFloatPtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotDigitalFloatPtrV(label_id string, xs, ys *float32, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.ImPlot_PlotDigital_FloatPtr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitalS16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotDigitalS16PtrV(label_id string, xs, ys *int16, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.ImPlot_PlotDigital_S16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitalS32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotDigitalS32PtrV(label_id string, xs, ys *int32, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.ImPlot_PlotDigital_S32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitalS64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotDigitalS64PtrV(label_id string, xs, ys *int64, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.ImPlot_PlotDigital_S64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitalS8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotDigitalS8PtrV(label_id string, xs, ys *int8, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.ImPlot_PlotDigital_S8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitalU16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotDigitalU16PtrV(label_id string, xs, ys *uint16, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.ImPlot_PlotDigital_U16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitalU32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotDigitalU32PtrV(label_id string, xs, ys *uint32, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.ImPlot_PlotDigital_U32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitalU64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotDigitalU64PtrV(label_id string, xs, ys *uint64, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.ImPlot_PlotDigital_U64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitalU8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotDigitalU8PtrV(label_id string, xs, ys *byte, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.ImPlot_PlotDigital_U8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDigitaldoublePtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotDigitaldoublePtrV(label_id string, xs, ys *float64, count int32, flags DigitalFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.ImPlot_PlotDigital_doublePtr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotDigitalFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotDummyV parameter default value hint:
// flags: 0
func PlotDummyV(label_id string, flags DummyFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	C.ImPlot_PlotDummy(label_idArg, C.ImPlotDummyFlags(flags))

	label_idFin()
}

// PlotErrorBarsFloatPtrFloatPtrFloatPtrFloatPtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotErrorBarsFloatPtrFloatPtrFloatPtrFloatPtrV(label_id string, xs, ys, neg, pos *float32, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	negArg, negFin := internal.WrapNumberPtr[C.float, float32](neg)
	posArg, posFin := internal.WrapNumberPtr[C.float, float32](pos)
	C.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotErrorBarsFloatPtrFloatPtrFloatPtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotErrorBarsFloatPtrFloatPtrFloatPtrIntV(label_id string, xs, ys, err *float32, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	errArg, errFin := internal.WrapNumberPtr[C.float, float32](err)
	C.ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsS16PtrS16PtrS16PtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotErrorBarsS16PtrS16PtrS16PtrIntV(label_id string, xs, ys, err *int16, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImS16, int16](err)
	C.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsS16PtrS16PtrS16PtrS16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotErrorBarsS16PtrS16PtrS16PtrS16PtrV(label_id string, xs, ys, neg, pos *int16, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImS16, int16](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImS16, int16](pos)
	C.ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotErrorBarsS32PtrS32PtrS32PtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotErrorBarsS32PtrS32PtrS32PtrIntV(label_id string, xs, ys, err *int32, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImS32, int32](err)
	C.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsS32PtrS32PtrS32PtrS32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotErrorBarsS32PtrS32PtrS32PtrS32PtrV(label_id string, xs, ys, neg, pos *int32, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImS32, int32](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImS32, int32](pos)
	C.ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotErrorBarsS64PtrS64PtrS64PtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotErrorBarsS64PtrS64PtrS64PtrIntV(label_id string, xs, ys, err *int64, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImS64, int64](err)
	C.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsS64PtrS64PtrS64PtrS64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotErrorBarsS64PtrS64PtrS64PtrS64PtrV(label_id string, xs, ys, neg, pos *int64, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImS64, int64](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImS64, int64](pos)
	C.ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotErrorBarsS8PtrS8PtrS8PtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotErrorBarsS8PtrS8PtrS8PtrIntV(label_id string, xs, ys, err *int8, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImS8, int8](err)
	C.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsS8PtrS8PtrS8PtrS8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotErrorBarsS8PtrS8PtrS8PtrS8PtrV(label_id string, xs, ys, neg, pos *int8, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImS8, int8](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImS8, int8](pos)
	C.ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotErrorBarsU16PtrU16PtrU16PtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotErrorBarsU16PtrU16PtrU16PtrIntV(label_id string, xs, ys, err *uint16, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImU16, uint16](err)
	C.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsU16PtrU16PtrU16PtrU16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotErrorBarsU16PtrU16PtrU16PtrU16PtrV(label_id string, xs, ys, neg, pos *uint16, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImU16, uint16](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImU16, uint16](pos)
	C.ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotErrorBarsU32PtrU32PtrU32PtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotErrorBarsU32PtrU32PtrU32PtrIntV(label_id string, xs, ys, err *uint32, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImU32, uint32](err)
	C.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsU32PtrU32PtrU32PtrU32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotErrorBarsU32PtrU32PtrU32PtrU32PtrV(label_id string, xs, ys, neg, pos *uint32, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImU32, uint32](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImU32, uint32](pos)
	C.ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotErrorBarsU64PtrU64PtrU64PtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotErrorBarsU64PtrU64PtrU64PtrIntV(label_id string, xs, ys, err *uint64, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImU64, uint64](err)
	C.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsU64PtrU64PtrU64PtrU64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotErrorBarsU64PtrU64PtrU64PtrU64PtrV(label_id string, xs, ys, neg, pos *uint64, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImU64, uint64](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImU64, uint64](pos)
	C.ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotErrorBarsU8PtrU8PtrU8PtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotErrorBarsU8PtrU8PtrU8PtrIntV(label_id string, xs, ys, err *byte, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImU8, byte](err)
	C.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsU8PtrU8PtrU8PtrU8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotErrorBarsU8PtrU8PtrU8PtrU8PtrV(label_id string, xs, ys, neg, pos *byte, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImU8, byte](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImU8, byte](pos)
	C.ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotErrorBarsdoublePtrdoublePtrdoublePtrIntV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotErrorBarsdoublePtrdoublePtrdoublePtrIntV(label_id string, xs, ys, err *float64, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	errArg, errFin := internal.WrapNumberPtr[C.double, float64](err)
	C.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

// PlotErrorBarsdoublePtrdoublePtrdoublePtrdoublePtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotErrorBarsdoublePtrdoublePtrdoublePtrdoublePtrV(label_id string, xs, ys, neg, pos *float64, count int32, flags ErrorBarsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	negArg, negFin := internal.WrapNumberPtr[C.double, float64](neg)
	posArg, posFin := internal.WrapNumberPtr[C.double, float64](pos)
	C.ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count), C.ImPlotErrorBarsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

// PlotHeatmapFloatPtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapFloatPtrV(label_id string, values *float32, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_FloatPtr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHeatmapS16PtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapS16PtrV(label_id string, values *int16, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_S16Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHeatmapS32PtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapS32PtrV(label_id string, values *int32, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_S32Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHeatmapS64PtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapS64PtrV(label_id string, values *int64, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_S64Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHeatmapS8PtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapS8PtrV(label_id string, values *int8, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_S8Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHeatmapU16PtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapU16PtrV(label_id string, values *uint16, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_U16Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHeatmapU32PtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapU32PtrV(label_id string, values *uint32, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_U32Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHeatmapU64PtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapU64PtrV(label_id string, values *uint64, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_U64Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHeatmapU8PtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapU8PtrV(label_id string, values *byte, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_U8Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHeatmapdoublePtrV parameter default value hint:
// scale_min: 0
// scale_max: 0
// label_fmt: "%.1f"
// bounds_min: ImPlotPoint(0,0)
// bounds_max: ImPlotPoint(1,1)
// flags: 0
func PlotHeatmapdoublePtrV(label_id string, values *float64, rows, cols int32, scale_min, scale_max float64, label_fmt string, bounds_min, bounds_max PlotPoint, flags HeatmapFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotHeatmap_doublePtr(label_idArg, valuesArg, C.int(rows), C.int(cols), C.double(scale_min), C.double(scale_max), label_fmtArg, internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), C.ImPlotHeatmapFlags(flags))

	label_idFin()
	valuesFin()
	label_fmtFin()
}

// PlotHistogram2DFloatPtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DFloatPtrV(label_id string, xs, ys *float32, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_FloatPtr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogram2DS16PtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DS16PtrV(label_id string, xs, ys *int16, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_S16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogram2DS32PtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DS32PtrV(label_id string, xs, ys *int32, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_S32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogram2DS64PtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DS64PtrV(label_id string, xs, ys *int64, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_S64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogram2DS8PtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DS8PtrV(label_id string, xs, ys *int8, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_S8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogram2DU16PtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DU16PtrV(label_id string, xs, ys *uint16, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_U16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogram2DU32PtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DU32PtrV(label_id string, xs, ys *uint32, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_U32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogram2DU64PtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DU64PtrV(label_id string, xs, ys *uint64, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_U64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogram2DU8PtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DU8PtrV(label_id string, xs, ys *byte, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_U8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogram2DdoublePtrV parameter default value hint:
// x_bins: ImPlotBin_Sturges
// y_bins: ImPlotBin_Sturges
// flags: 0
func PlotHistogram2DdoublePtrV(label_id string, xs, ys *float64, count, x_bins, y_bins int32, rangeArg Rect, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram2D_doublePtr(label_idArg, xsArg, ysArg, C.int(count), C.int(x_bins), C.int(y_bins), internal.ReinterpretCast[C.ImPlotRect](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramFloatPtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramFloatPtrV(label_id string, values *float32, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_FloatPtr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramS16PtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramS16PtrV(label_id string, values *int16, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_S16Ptr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramS32PtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramS32PtrV(label_id string, values *int32, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_S32Ptr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramS64PtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramS64PtrV(label_id string, values *int64, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_S64Ptr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramS8PtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramS8PtrV(label_id string, values *int8, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_S8Ptr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramU16PtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramU16PtrV(label_id string, values *uint16, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_U16Ptr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramU32PtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramU32PtrV(label_id string, values *uint32, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_U32Ptr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramU64PtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramU64PtrV(label_id string, values *uint64, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_U64Ptr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramU8PtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramU8PtrV(label_id string, values *byte, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_U8Ptr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotHistogramdoublePtrV parameter default value hint:
// bins: ImPlotBin_Sturges
// bar_scale: 1.0
// flags: 0
func PlotHistogramdoublePtrV(label_id string, values *float64, count, bins int32, bar_scale float64, rangeArg Range, flags HistogramFlags) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	rangeArgArg, rangeArgFin := rangeArg.C()

	defer func() {
		label_idFin()
		valuesFin()
		rangeArgFin()
	}()
	return float64(C.ImPlot_PlotHistogram_doublePtr(label_idArg, valuesArg, C.int(count), C.int(bins), C.double(bar_scale), internal.ReinterpretCast[C.ImPlotRange](rangeArgArg), C.ImPlotHistogramFlags(flags)))
}

// PlotImageV parameter default value hint:
// uv0: ImVec2(0,0)
// uv1: ImVec2(1,1)
// tint_col: ImVec4(1,1,1,1)
// flags: 0
func PlotImageV(label_id string, tex_ref imgui.TextureRef, bounds_min, bounds_max PlotPoint, uv0, uv1 imgui.Vec2, tint_col imgui.Vec4, flags ImageFlags) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	tex_refArg, tex_refFin := tex_ref.C()
	C.ImPlot_PlotImage(label_idArg, internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()), internal.ReinterpretCast[C.ImVec2](uv0.ToC()), internal.ReinterpretCast[C.ImVec2](uv1.ToC()), internal.ReinterpretCast[C.ImVec4](tint_col.ToC()), C.ImPlotImageFlags(flags))

	label_idFin()
	tex_refFin()
}

// PlotInfLinesFloatPtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotInfLinesFloatPtrV(label_id string, values *float32, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.ImPlot_PlotInfLines_FloatPtr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotInfLinesS16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotInfLinesS16PtrV(label_id string, values *int16, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.ImPlot_PlotInfLines_S16Ptr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotInfLinesS32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotInfLinesS32PtrV(label_id string, values *int32, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.ImPlot_PlotInfLines_S32Ptr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotInfLinesS64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotInfLinesS64PtrV(label_id string, values *int64, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.ImPlot_PlotInfLines_S64Ptr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotInfLinesS8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotInfLinesS8PtrV(label_id string, values *int8, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.ImPlot_PlotInfLines_S8Ptr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotInfLinesU16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotInfLinesU16PtrV(label_id string, values *uint16, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.ImPlot_PlotInfLines_U16Ptr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotInfLinesU32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotInfLinesU32PtrV(label_id string, values *uint32, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.ImPlot_PlotInfLines_U32Ptr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotInfLinesU64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotInfLinesU64PtrV(label_id string, values *uint64, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.ImPlot_PlotInfLines_U64Ptr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotInfLinesU8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotInfLinesU8PtrV(label_id string, values *byte, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.ImPlot_PlotInfLines_U8Ptr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotInfLinesdoublePtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotInfLinesdoublePtrV(label_id string, values *float64, count int32, flags InfLinesFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.ImPlot_PlotInfLines_doublePtr(label_idArg, valuesArg, C.int(count), C.ImPlotInfLinesFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineFloatPtrFloatPtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotLineFloatPtrFloatPtrV(label_id string, xs, ys *float32, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.ImPlot_PlotLine_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotLineFloatPtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotLineFloatPtrIntV(label_id string, values *float32, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.ImPlot_PlotLine_FloatPtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineS16PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotLineS16PtrIntV(label_id string, values *int16, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.ImPlot_PlotLine_S16PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineS16PtrS16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotLineS16PtrS16PtrV(label_id string, xs, ys *int16, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.ImPlot_PlotLine_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotLineS32PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotLineS32PtrIntV(label_id string, values *int32, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.ImPlot_PlotLine_S32PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineS32PtrS32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotLineS32PtrS32PtrV(label_id string, xs, ys *int32, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.ImPlot_PlotLine_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotLineS64PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotLineS64PtrIntV(label_id string, values *int64, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.ImPlot_PlotLine_S64PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineS64PtrS64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotLineS64PtrS64PtrV(label_id string, xs, ys *int64, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.ImPlot_PlotLine_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotLineS8PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotLineS8PtrIntV(label_id string, values *int8, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.ImPlot_PlotLine_S8PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineS8PtrS8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotLineS8PtrS8PtrV(label_id string, xs, ys *int8, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.ImPlot_PlotLine_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotLineU16PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotLineU16PtrIntV(label_id string, values *uint16, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.ImPlot_PlotLine_U16PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineU16PtrU16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotLineU16PtrU16PtrV(label_id string, xs, ys *uint16, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.ImPlot_PlotLine_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotLineU32PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotLineU32PtrIntV(label_id string, values *uint32, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.ImPlot_PlotLine_U32PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineU32PtrU32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotLineU32PtrU32PtrV(label_id string, xs, ys *uint32, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.ImPlot_PlotLine_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotLineU64PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotLineU64PtrIntV(label_id string, values *uint64, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.ImPlot_PlotLine_U64PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineU64PtrU64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotLineU64PtrU64PtrV(label_id string, xs, ys *uint64, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.ImPlot_PlotLine_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotLineU8PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotLineU8PtrIntV(label_id string, values *byte, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.ImPlot_PlotLine_U8PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLineU8PtrU8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotLineU8PtrU8PtrV(label_id string, xs, ys *byte, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.ImPlot_PlotLine_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotLinedoublePtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotLinedoublePtrIntV(label_id string, values *float64, count int32, xscale, xstart float64, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.ImPlot_PlotLine_doublePtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotLinedoublePtrdoublePtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotLinedoublePtrdoublePtrV(label_id string, xs, ys *float64, count int32, flags LineFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.ImPlot_PlotLine_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotLineFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotPieChartFloatPtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartFloatPtrPlotFormatterV(label_ids []string, values *float32, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_FloatPtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartFloatPtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartFloatPtrStrV(label_ids []string, values *float32, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_FloatPtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotPieChartS16PtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartS16PtrPlotFormatterV(label_ids []string, values *int16, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_S16PtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartS16PtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartS16PtrStrV(label_ids []string, values *int16, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_S16PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotPieChartS32PtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartS32PtrPlotFormatterV(label_ids []string, values *int32, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_S32PtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartS32PtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartS32PtrStrV(label_ids []string, values *int32, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_S32PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotPieChartS64PtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartS64PtrPlotFormatterV(label_ids []string, values *int64, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_S64PtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartS64PtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartS64PtrStrV(label_ids []string, values *int64, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_S64PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotPieChartS8PtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartS8PtrPlotFormatterV(label_ids []string, values *int8, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_S8PtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartS8PtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartS8PtrStrV(label_ids []string, values *int8, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_S8PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotPieChartU16PtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartU16PtrPlotFormatterV(label_ids []string, values *uint16, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_U16PtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartU16PtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartU16PtrStrV(label_ids []string, values *uint16, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_U16PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotPieChartU32PtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartU32PtrPlotFormatterV(label_ids []string, values *uint32, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_U32PtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartU32PtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartU32PtrStrV(label_ids []string, values *uint32, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_U32PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotPieChartU64PtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartU64PtrPlotFormatterV(label_ids []string, values *uint64, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_U64PtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartU64PtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartU64PtrStrV(label_ids []string, values *uint64, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_U64PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotPieChartU8PtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartU8PtrPlotFormatterV(label_ids []string, values *byte, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_U8PtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartU8PtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartU8PtrStrV(label_ids []string, values *byte, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_U8PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotPieChartdoublePtrPlotFormatterV parameter default value hint:
// fmt_data: nullptr
// angle0: 90
// flags: 0
func PlotPieChartdoublePtrPlotFormatterV(label_ids []string, values *float64, count int32, x, y, radius float64, fmt Formatter, fmt_data uintptr, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_doublePtrPlotFormatterV(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg), C.uintptr_t(fmt_data), C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	fmtFin()
}

// PlotPieChartdoublePtrStrV parameter default value hint:
// label_fmt: "%.1f"
// angle0: 90
// flags: 0
func PlotPieChartdoublePtrStrV(label_ids []string, values *float64, count int32, x, y, radius float64, label_fmt string, angle0 float64, flags PieChartFlags) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	label_fmtArg, label_fmtFin := internal.WrapString[C.char](label_fmt)
	C.ImPlot_PlotPieChart_doublePtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), label_fmtArg, C.double(angle0), C.ImPlotPieChartFlags(flags))

	label_idsFin()
	valuesFin()
	label_fmtFin()
}

// PlotScatterFloatPtrFloatPtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotScatterFloatPtrFloatPtrV(label_id string, xs, ys *float32, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.ImPlot_PlotScatter_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotScatterFloatPtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotScatterFloatPtrIntV(label_id string, values *float32, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.ImPlot_PlotScatter_FloatPtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterS16PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotScatterS16PtrIntV(label_id string, values *int16, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.ImPlot_PlotScatter_S16PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterS16PtrS16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotScatterS16PtrS16PtrV(label_id string, xs, ys *int16, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.ImPlot_PlotScatter_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotScatterS32PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotScatterS32PtrIntV(label_id string, values *int32, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.ImPlot_PlotScatter_S32PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterS32PtrS32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotScatterS32PtrS32PtrV(label_id string, xs, ys *int32, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.ImPlot_PlotScatter_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotScatterS64PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotScatterS64PtrIntV(label_id string, values *int64, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.ImPlot_PlotScatter_S64PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterS64PtrS64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotScatterS64PtrS64PtrV(label_id string, xs, ys *int64, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.ImPlot_PlotScatter_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotScatterS8PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotScatterS8PtrIntV(label_id string, values *int8, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.ImPlot_PlotScatter_S8PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterS8PtrS8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotScatterS8PtrS8PtrV(label_id string, xs, ys *int8, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.ImPlot_PlotScatter_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotScatterU16PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotScatterU16PtrIntV(label_id string, values *uint16, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.ImPlot_PlotScatter_U16PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterU16PtrU16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotScatterU16PtrU16PtrV(label_id string, xs, ys *uint16, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.ImPlot_PlotScatter_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotScatterU32PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotScatterU32PtrIntV(label_id string, values *uint32, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.ImPlot_PlotScatter_U32PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterU32PtrU32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotScatterU32PtrU32PtrV(label_id string, xs, ys *uint32, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.ImPlot_PlotScatter_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotScatterU64PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotScatterU64PtrIntV(label_id string, values *uint64, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.ImPlot_PlotScatter_U64PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterU64PtrU64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotScatterU64PtrU64PtrV(label_id string, xs, ys *uint64, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.ImPlot_PlotScatter_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotScatterU8PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotScatterU8PtrIntV(label_id string, values *byte, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.ImPlot_PlotScatter_U8PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterU8PtrU8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotScatterU8PtrU8PtrV(label_id string, xs, ys *byte, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.ImPlot_PlotScatter_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotScatterdoublePtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotScatterdoublePtrIntV(label_id string, values *float64, count int32, xscale, xstart float64, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.ImPlot_PlotScatter_doublePtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotScatterdoublePtrdoublePtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotScatterdoublePtrdoublePtrV(label_id string, xs, ys *float64, count int32, flags ScatterFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.ImPlot_PlotScatter_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotScatterFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedFloatPtrFloatPtrFloatPtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotShadedFloatPtrFloatPtrFloatPtrV(label_id string, xs, ys1, ys2 *float32, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.float, float32](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.float, float32](ys2)
	C.ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotShadedFloatPtrFloatPtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotShadedFloatPtrFloatPtrIntV(label_id string, xs, ys *float32, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.ImPlot_PlotShaded_FloatPtrFloatPtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedFloatPtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotShadedFloatPtrIntV(label_id string, values *float32, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.ImPlot_PlotShaded_FloatPtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadedS16PtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotShadedS16PtrIntV(label_id string, values *int16, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.ImPlot_PlotShaded_S16PtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadedS16PtrS16PtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotShadedS16PtrS16PtrIntV(label_id string, xs, ys *int16, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.ImPlot_PlotShaded_S16PtrS16PtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedS16PtrS16PtrS16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotShadedS16PtrS16PtrS16PtrV(label_id string, xs, ys1, ys2 *int16, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImS16, int16](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImS16, int16](ys2)
	C.ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotShadedS32PtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotShadedS32PtrIntV(label_id string, values *int32, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.ImPlot_PlotShaded_S32PtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadedS32PtrS32PtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotShadedS32PtrS32PtrIntV(label_id string, xs, ys *int32, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.ImPlot_PlotShaded_S32PtrS32PtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedS32PtrS32PtrS32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotShadedS32PtrS32PtrS32PtrV(label_id string, xs, ys1, ys2 *int32, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImS32, int32](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImS32, int32](ys2)
	C.ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotShadedS64PtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotShadedS64PtrIntV(label_id string, values *int64, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.ImPlot_PlotShaded_S64PtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadedS64PtrS64PtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotShadedS64PtrS64PtrIntV(label_id string, xs, ys *int64, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.ImPlot_PlotShaded_S64PtrS64PtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedS64PtrS64PtrS64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotShadedS64PtrS64PtrS64PtrV(label_id string, xs, ys1, ys2 *int64, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImS64, int64](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImS64, int64](ys2)
	C.ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotShadedS8PtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotShadedS8PtrIntV(label_id string, values *int8, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.ImPlot_PlotShaded_S8PtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadedS8PtrS8PtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotShadedS8PtrS8PtrIntV(label_id string, xs, ys *int8, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.ImPlot_PlotShaded_S8PtrS8PtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedS8PtrS8PtrS8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotShadedS8PtrS8PtrS8PtrV(label_id string, xs, ys1, ys2 *int8, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImS8, int8](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImS8, int8](ys2)
	C.ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotShadedU16PtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotShadedU16PtrIntV(label_id string, values *uint16, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.ImPlot_PlotShaded_U16PtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadedU16PtrU16PtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotShadedU16PtrU16PtrIntV(label_id string, xs, ys *uint16, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.ImPlot_PlotShaded_U16PtrU16PtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedU16PtrU16PtrU16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotShadedU16PtrU16PtrU16PtrV(label_id string, xs, ys1, ys2 *uint16, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImU16, uint16](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImU16, uint16](ys2)
	C.ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotShadedU32PtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotShadedU32PtrIntV(label_id string, values *uint32, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.ImPlot_PlotShaded_U32PtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadedU32PtrU32PtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotShadedU32PtrU32PtrIntV(label_id string, xs, ys *uint32, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.ImPlot_PlotShaded_U32PtrU32PtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedU32PtrU32PtrU32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotShadedU32PtrU32PtrU32PtrV(label_id string, xs, ys1, ys2 *uint32, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImU32, uint32](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImU32, uint32](ys2)
	C.ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotShadedU64PtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotShadedU64PtrIntV(label_id string, values *uint64, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.ImPlot_PlotShaded_U64PtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadedU64PtrU64PtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotShadedU64PtrU64PtrIntV(label_id string, xs, ys *uint64, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.ImPlot_PlotShaded_U64PtrU64PtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedU64PtrU64PtrU64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotShadedU64PtrU64PtrU64PtrV(label_id string, xs, ys1, ys2 *uint64, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImU64, uint64](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImU64, uint64](ys2)
	C.ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotShadedU8PtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotShadedU8PtrIntV(label_id string, values *byte, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.ImPlot_PlotShaded_U8PtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadedU8PtrU8PtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotShadedU8PtrU8PtrIntV(label_id string, xs, ys *byte, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.ImPlot_PlotShaded_U8PtrU8PtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadedU8PtrU8PtrU8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotShadedU8PtrU8PtrU8PtrV(label_id string, xs, ys1, ys2 *byte, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImU8, byte](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImU8, byte](ys2)
	C.ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotShadeddoublePtrIntV parameter default value hint:
// yref: 0
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotShadeddoublePtrIntV(label_id string, values *float64, count int32, yref, xscale, xstart float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.ImPlot_PlotShaded_doublePtrInt(label_idArg, valuesArg, C.int(count), C.double(yref), C.double(xscale), C.double(xstart), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotShadeddoublePtrdoublePtrIntV parameter default value hint:
// yref: 0
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotShadeddoublePtrdoublePtrIntV(label_id string, xs, ys *float64, count int32, yref float64, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.ImPlot_PlotShaded_doublePtrdoublePtrInt(label_idArg, xsArg, ysArg, C.int(count), C.double(yref), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotShadeddoublePtrdoublePtrdoublePtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotShadeddoublePtrdoublePtrdoublePtrV(label_id string, xs, ys1, ys2 *float64, count int32, flags ShadedFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.double, float64](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.double, float64](ys2)
	C.ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count), C.ImPlotShadedFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

// PlotStairsFloatPtrFloatPtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotStairsFloatPtrFloatPtrV(label_id string, xs, ys *float32, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.ImPlot_PlotStairs_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStairsFloatPtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotStairsFloatPtrIntV(label_id string, values *float32, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.ImPlot_PlotStairs_FloatPtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsS16PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotStairsS16PtrIntV(label_id string, values *int16, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.ImPlot_PlotStairs_S16PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsS16PtrS16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotStairsS16PtrS16PtrV(label_id string, xs, ys *int16, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.ImPlot_PlotStairs_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStairsS32PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotStairsS32PtrIntV(label_id string, values *int32, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.ImPlot_PlotStairs_S32PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsS32PtrS32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotStairsS32PtrS32PtrV(label_id string, xs, ys *int32, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.ImPlot_PlotStairs_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStairsS64PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotStairsS64PtrIntV(label_id string, values *int64, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.ImPlot_PlotStairs_S64PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsS64PtrS64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotStairsS64PtrS64PtrV(label_id string, xs, ys *int64, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.ImPlot_PlotStairs_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStairsS8PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotStairsS8PtrIntV(label_id string, values *int8, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.ImPlot_PlotStairs_S8PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsS8PtrS8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotStairsS8PtrS8PtrV(label_id string, xs, ys *int8, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.ImPlot_PlotStairs_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStairsU16PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotStairsU16PtrIntV(label_id string, values *uint16, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.ImPlot_PlotStairs_U16PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsU16PtrU16PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotStairsU16PtrU16PtrV(label_id string, xs, ys *uint16, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.ImPlot_PlotStairs_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStairsU32PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotStairsU32PtrIntV(label_id string, values *uint32, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.ImPlot_PlotStairs_U32PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsU32PtrU32PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotStairsU32PtrU32PtrV(label_id string, xs, ys *uint32, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.ImPlot_PlotStairs_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStairsU64PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotStairsU64PtrIntV(label_id string, values *uint64, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.ImPlot_PlotStairs_U64PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsU64PtrU64PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotStairsU64PtrU64PtrV(label_id string, xs, ys *uint64, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.ImPlot_PlotStairs_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStairsU8PtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotStairsU8PtrIntV(label_id string, values *byte, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.ImPlot_PlotStairs_U8PtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsU8PtrU8PtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotStairsU8PtrU8PtrV(label_id string, xs, ys *byte, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.ImPlot_PlotStairs_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStairsdoublePtrIntV parameter default value hint:
// xscale: 1
// xstart: 0
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotStairsdoublePtrIntV(label_id string, values *float64, count int32, xscale, xstart float64, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.ImPlot_PlotStairs_doublePtrInt(label_idArg, valuesArg, C.int(count), C.double(xscale), C.double(xstart), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStairsdoublePtrdoublePtrV parameter default value hint:
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotStairsdoublePtrdoublePtrV(label_id string, xs, ys *float64, count int32, flags StairsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.ImPlot_PlotStairs_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count), C.ImPlotStairsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsFloatPtrFloatPtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotStemsFloatPtrFloatPtrV(label_id string, xs, ys *float32, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.ImPlot_PlotStems_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsFloatPtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(float)
func PlotStemsFloatPtrIntV(label_id string, values *float32, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.ImPlot_PlotStems_FloatPtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsS16PtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotStemsS16PtrIntV(label_id string, values *int16, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.ImPlot_PlotStems_S16PtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsS16PtrS16PtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS16)
func PlotStemsS16PtrS16PtrV(label_id string, xs, ys *int16, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.ImPlot_PlotStems_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsS32PtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotStemsS32PtrIntV(label_id string, values *int32, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.ImPlot_PlotStems_S32PtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsS32PtrS32PtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS32)
func PlotStemsS32PtrS32PtrV(label_id string, xs, ys *int32, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.ImPlot_PlotStems_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsS64PtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotStemsS64PtrIntV(label_id string, values *int64, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.ImPlot_PlotStems_S64PtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsS64PtrS64PtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS64)
func PlotStemsS64PtrS64PtrV(label_id string, xs, ys *int64, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.ImPlot_PlotStems_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsS8PtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotStemsS8PtrIntV(label_id string, values *int8, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.ImPlot_PlotStems_S8PtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsS8PtrS8PtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImS8)
func PlotStemsS8PtrS8PtrV(label_id string, xs, ys *int8, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.ImPlot_PlotStems_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsU16PtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotStemsU16PtrIntV(label_id string, values *uint16, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.ImPlot_PlotStems_U16PtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsU16PtrU16PtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU16)
func PlotStemsU16PtrU16PtrV(label_id string, xs, ys *uint16, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.ImPlot_PlotStems_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsU32PtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotStemsU32PtrIntV(label_id string, values *uint32, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.ImPlot_PlotStems_U32PtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsU32PtrU32PtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU32)
func PlotStemsU32PtrU32PtrV(label_id string, xs, ys *uint32, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.ImPlot_PlotStems_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsU64PtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotStemsU64PtrIntV(label_id string, values *uint64, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.ImPlot_PlotStems_U64PtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsU64PtrU64PtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU64)
func PlotStemsU64PtrU64PtrV(label_id string, xs, ys *uint64, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.ImPlot_PlotStems_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsU8PtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotStemsU8PtrIntV(label_id string, values *byte, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.ImPlot_PlotStems_U8PtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsU8PtrU8PtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(ImU8)
func PlotStemsU8PtrU8PtrV(label_id string, xs, ys *byte, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.ImPlot_PlotStems_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotStemsdoublePtrIntV parameter default value hint:
// ref: 0
// scale: 1
// start: 0
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotStemsdoublePtrIntV(label_id string, values *float64, count int32, ref, scale, start float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.ImPlot_PlotStems_doublePtrInt(label_idArg, valuesArg, C.int(count), C.double(ref), C.double(scale), C.double(start), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	valuesFin()
}

// PlotStemsdoublePtrdoublePtrV parameter default value hint:
// ref: 0
// flags: 0
// offset: 0
// stride: sizeof(double)
func PlotStemsdoublePtrdoublePtrV(label_id string, xs, ys *float64, count int32, ref float64, flags StemsFlags, offset, stride int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.ImPlot_PlotStems_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count), C.double(ref), C.ImPlotStemsFlags(flags), C.int(offset), C.int(stride))

	label_idFin()
	xsFin()
	ysFin()
}

// PlotTextV parameter default value hint:
// pix_offset: ImVec2(0,0)
// flags: 0
func PlotTextV(text string, x, y float64, pix_offset imgui.Vec2, flags TextFlags) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.ImPlot_PlotText(textArg, C.double(x), C.double(y), internal.ReinterpretCast[C.ImVec2](pix_offset.ToC()), C.ImPlotTextFlags(flags))

	textFin()
}

// PlotToPixelsPlotPoIntV parameter default value hint:
// x_axis: -1
// y_axis: -1
func PlotToPixelsPlotPoIntV(plt PlotPoint, x_axis, y_axis AxisEnum) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_PlotToPixels_PlotPoInt(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImPlotPoint](plt.ToC()), C.ImAxis(x_axis), C.ImAxis(y_axis))

	pOutFin()

	return *pOut
}

// PlotToPixelsdoubleV parameter default value hint:
// x_axis: -1
// y_axis: -1
func PlotToPixelsdoubleV(x, y float64, x_axis, y_axis AxisEnum) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_PlotToPixels_double(internal.ReinterpretCast[*C.ImVec2](pOutArg), C.double(x), C.double(y), C.ImAxis(x_axis), C.ImAxis(y_axis))

	pOutFin()

	return *pOut
}

// PopColormapV parameter default value hint:
// count: 1
func PopColormapV(count int32) {
	C.ImPlot_PopColormap(C.int(count))
}

func PopPlotClipRect() {
	C.ImPlot_PopPlotClipRect()
}

// PopStyleColorV parameter default value hint:
// count: 1
func PopStyleColorV(count int32) {
	C.ImPlot_PopStyleColor(C.int(count))
}

// PopStyleVarV parameter default value hint:
// count: 1
func PopStyleVarV(count int32) {
	C.ImPlot_PopStyleVar(C.int(count))
}

func Precision(val float64) int32 {
	return int32(C.ImPlot_Precision(C.double(val)))
}

func PushColormapPlotColormap(cmap Colormap) {
	C.ImPlot_PushColormap_PlotColormap(C.ImPlotColormap(cmap))
}

func PushColormapStr(name string) {
	nameArg, nameFin := internal.WrapString[C.char](name)
	C.ImPlot_PushColormap_Str(nameArg)

	nameFin()
}

// PushPlotClipRectV parameter default value hint:
// expand: 0
func PushPlotClipRectV(expand float32) {
	C.ImPlot_PushPlotClipRect(C.float(expand))
}

func PushStyleColorU32(idx Col, col uint32) {
	C.ImPlot_PushStyleColor_U32(C.ImPlotCol(idx), C.ImU32(col))
}

func PushStyleColorVec4(idx Col, col imgui.Vec4) {
	C.ImPlot_PushStyleColor_Vec4(C.ImPlotCol(idx), internal.ReinterpretCast[C.ImVec4](col.ToC()))
}

func PushStyleVarFloat(idx StyleVar, val float32) {
	C.ImPlot_PushStyleVar_Float(C.ImPlotStyleVar(idx), C.float(val))
}

func PushStyleVarInt(idx StyleVar, val int32) {
	C.ImPlot_PushStyleVar_Int(C.ImPlotStyleVar(idx), C.int(val))
}

func PushStyleVarVec2(idx StyleVar, val imgui.Vec2) {
	C.ImPlot_PushStyleVar_Vec2(C.ImPlotStyleVar(idx), internal.ReinterpretCast[C.ImVec2](val.ToC()))
}

func RangesOverlap(r1, r2 Range) bool {
	r1Arg, r1Fin := r1.C()
	r2Arg, r2Fin := r2.C()

	defer func() {
		r1Fin()
		r2Fin()
	}()
	return C.ImPlot_RangesOverlap(internal.ReinterpretCast[C.ImPlotRange](r1Arg), internal.ReinterpretCast[C.ImPlotRange](r2Arg)) == C.bool(true)
}

// RegisterOrGetItemV parameter default value hint:
// just_created: nullptr
func RegisterOrGetItemV(label_id string, flags ItemFlags, just_created *bool) *Item {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	just_createdArg, just_createdFin := internal.WrapNumberPtr[C.bool, bool](just_created)

	defer func() {
		label_idFin()
		just_createdFin()
	}()
	return NewItemFromC(C.ImPlot_RegisterOrGetItem(label_idArg, C.ImPlotItemFlags(flags), just_createdArg))
}

func RenderColorBar(colors *uint32, size int32, DrawList *imgui.DrawList, bounds imgui.Rect, vert, reversed, continuous bool) {
	colorsArg, colorsFin := internal.WrapNumberPtr[C.ImU32, uint32](colors)
	DrawListArg, DrawListFin := DrawList.Handle()
	C.ImPlot_RenderColorBar(colorsArg, C.int(size), internal.ReinterpretCast[*C.ImDrawList](DrawListArg), internal.ReinterpretCast[C.ImRect](bounds.ToC()), C.bool(vert), C.bool(reversed), C.bool(continuous))

	colorsFin()
	DrawListFin()
}

func ResetCtxForNextAlignedPlots(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.ImPlot_ResetCtxForNextAlignedPlots(internal.ReinterpretCast[*C.ImPlotContext](ctxArg))

	ctxFin()
}

func ResetCtxForNextPlot(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.ImPlot_ResetCtxForNextPlot(internal.ReinterpretCast[*C.ImPlotContext](ctxArg))

	ctxFin()
}

func ResetCtxForNextSubplot(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.ImPlot_ResetCtxForNextSubplot(internal.ReinterpretCast[*C.ImPlotContext](ctxArg))

	ctxFin()
}

func RoundTime(t PlotTime, unit TimeUnit) PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_RoundTime(internal.ReinterpretCast[*C.ImPlotTime](pOutArg), internal.ReinterpretCast[C.ImPlotTime](t.ToC()), C.ImPlotTimeUnit(unit))

	pOutFin()

	return *pOut
}

func RoundTo(val float64, prec int32) float64 {
	return float64(C.ImPlot_RoundTo(C.double(val), C.int(prec)))
}

// SampleColormapV parameter default value hint:
// cmap: -1
func SampleColormapV(t float32, cmap Colormap) imgui.Vec4 {
	pOut := new(imgui.Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_SampleColormap(internal.ReinterpretCast[*C.ImVec4](pOutArg), C.float(t), C.ImPlotColormap(cmap))

	pOutFin()

	return *pOut
}

func SampleColormapU32(t float32, cmap Colormap) uint32 {
	return (uint32)(C.ImPlot_SampleColormapU32(C.float(t), C.ImPlotColormap(cmap)))
}

func SetAxes(x_axis, y_axis AxisEnum) {
	C.ImPlot_SetAxes(C.ImAxis(x_axis), C.ImAxis(y_axis))
}

func SetAxis(axis AxisEnum) {
	C.ImPlot_SetAxis(C.ImAxis(axis))
}

func SetCurrentContext(ctx *Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.ImPlot_SetCurrentContext(internal.ReinterpretCast[*C.ImPlotContext](ctxArg))

	ctxFin()
}

func SetImGuiContext(ctx *imgui.Context) {
	ctxArg, ctxFin := ctx.Handle()
	C.ImPlot_SetImGuiContext(internal.ReinterpretCast[*C.ImGuiContext](ctxArg))

	ctxFin()
}

// SetNextAxesLimitsV parameter default value hint:
// cond: ImPlotCond_Once
func SetNextAxesLimitsV(x_min, x_max, y_min, y_max float64, cond Cond) {
	C.ImPlot_SetNextAxesLimits(C.double(x_min), C.double(x_max), C.double(y_min), C.double(y_max), C.ImPlotCond(cond))
}

func SetNextAxesToFit() {
	C.ImPlot_SetNextAxesToFit()
}

// SetNextAxisLimitsV parameter default value hint:
// cond: ImPlotCond_Once
func SetNextAxisLimitsV(axis AxisEnum, v_min, v_max float64, cond Cond) {
	C.ImPlot_SetNextAxisLimits(C.ImAxis(axis), C.double(v_min), C.double(v_max), C.ImPlotCond(cond))
}

func SetNextAxisLinks(axis AxisEnum, link_min, link_max *float64) {
	link_minArg, link_minFin := internal.WrapNumberPtr[C.double, float64](link_min)
	link_maxArg, link_maxFin := internal.WrapNumberPtr[C.double, float64](link_max)
	C.ImPlot_SetNextAxisLinks(C.ImAxis(axis), link_minArg, link_maxArg)

	link_minFin()
	link_maxFin()
}

func SetNextAxisToFit(axis AxisEnum) {
	C.ImPlot_SetNextAxisToFit(C.ImAxis(axis))
}

// SetNextErrorBarStyleV parameter default value hint:
// col: ImVec4(0,0,0,-1)
// size: -1
// weight: -1
func SetNextErrorBarStyleV(col imgui.Vec4, size, weight float32) {
	C.ImPlot_SetNextErrorBarStyle(internal.ReinterpretCast[C.ImVec4](col.ToC()), C.float(size), C.float(weight))
}

// SetNextFillStyleV parameter default value hint:
// col: ImVec4(0,0,0,-1)
// alpha_mod: -1
func SetNextFillStyleV(col imgui.Vec4, alpha_mod float32) {
	C.ImPlot_SetNextFillStyle(internal.ReinterpretCast[C.ImVec4](col.ToC()), C.float(alpha_mod))
}

// SetNextLineStyleV parameter default value hint:
// col: ImVec4(0,0,0,-1)
// weight: -1
func SetNextLineStyleV(col imgui.Vec4, weight float32) {
	C.ImPlot_SetNextLineStyle(internal.ReinterpretCast[C.ImVec4](col.ToC()), C.float(weight))
}

// SetNextMarkerStyleV parameter default value hint:
// marker: -1
// size: -1
// fill: ImVec4(0,0,0,-1)
// weight: -1
// outline: ImVec4(0,0,0,-1)
func SetNextMarkerStyleV(marker Marker, size float32, fill imgui.Vec4, weight float32, outline imgui.Vec4) {
	C.ImPlot_SetNextMarkerStyle(C.ImPlotMarker(marker), C.float(size), internal.ReinterpretCast[C.ImVec4](fill.ToC()), C.float(weight), internal.ReinterpretCast[C.ImVec4](outline.ToC()))
}

// SetupAxesV parameter default value hint:
// x_flags: 0
// y_flags: 0
func SetupAxesV(x_label, y_label string, x_flags, y_flags AxisFlags) {
	x_labelArg, x_labelFin := internal.WrapString[C.char](x_label)
	y_labelArg, y_labelFin := internal.WrapString[C.char](y_label)
	C.ImPlot_SetupAxes(x_labelArg, y_labelArg, C.ImPlotAxisFlags(x_flags), C.ImPlotAxisFlags(y_flags))

	x_labelFin()
	y_labelFin()
}

// SetupAxesLimitsV parameter default value hint:
// cond: ImPlotCond_Once
func SetupAxesLimitsV(x_min, x_max, y_min, y_max float64, cond Cond) {
	C.ImPlot_SetupAxesLimits(C.double(x_min), C.double(x_max), C.double(y_min), C.double(y_max), C.ImPlotCond(cond))
}

// SetupAxisV parameter default value hint:
// label: nullptr
// flags: 0
func SetupAxisV(axis AxisEnum, label string, flags AxisFlags) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.ImPlot_SetupAxis(C.ImAxis(axis), labelArg, C.ImPlotAxisFlags(flags))

	labelFin()
}

// SetupAxisFormatPlotFormatterV parameter default value hint:
// data: nullptr
func SetupAxisFormatPlotFormatterV(axis AxisEnum, formatter Formatter, data uintptr) {
	formatterArg, formatterFin := formatter.C()
	C.wrap_ImPlot_SetupAxisFormat_PlotFormatterV(C.ImAxis(axis), internal.ReinterpretCast[C.ImPlotFormatter](formatterArg), C.uintptr_t(data))

	formatterFin()
}

func SetupAxisFormatStr(axis AxisEnum, fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.ImPlot_SetupAxisFormat_Str(C.ImAxis(axis), fmtArg)

	fmtFin()
}

// SetupAxisLimitsV parameter default value hint:
// cond: ImPlotCond_Once
func SetupAxisLimitsV(axis AxisEnum, v_min, v_max float64, cond Cond) {
	C.ImPlot_SetupAxisLimits(C.ImAxis(axis), C.double(v_min), C.double(v_max), C.ImPlotCond(cond))
}

func SetupAxisLimitsConstraints(axis AxisEnum, v_min, v_max float64) {
	C.ImPlot_SetupAxisLimitsConstraints(C.ImAxis(axis), C.double(v_min), C.double(v_max))
}

func SetupAxisLinks(axis AxisEnum, link_min, link_max *float64) {
	link_minArg, link_minFin := internal.WrapNumberPtr[C.double, float64](link_min)
	link_maxArg, link_maxFin := internal.WrapNumberPtr[C.double, float64](link_max)
	C.ImPlot_SetupAxisLinks(C.ImAxis(axis), link_minArg, link_maxArg)

	link_minFin()
	link_maxFin()
}

func SetupAxisScalePlotScale(axis AxisEnum, scale Scale) {
	C.ImPlot_SetupAxisScale_PlotScale(C.ImAxis(axis), C.ImPlotScale(scale))
}

// SetupAxisScalePlotTransformV parameter default value hint:
// data: nullptr
func SetupAxisScalePlotTransformV(axis AxisEnum, forward, inverse Transform, data uintptr) {
	forwardArg, forwardFin := forward.C()
	inverseArg, inverseFin := inverse.C()
	C.wrap_ImPlot_SetupAxisScale_PlotTransformV(C.ImAxis(axis), internal.ReinterpretCast[C.ImPlotTransform](forwardArg), internal.ReinterpretCast[C.ImPlotTransform](inverseArg), C.uintptr_t(data))

	forwardFin()
	inverseFin()
}

// SetupAxisTicksdoubleV parameter default value hint:
// labels: nullptr
// keep_default: false
func SetupAxisTicksdoubleV(axis AxisEnum, v_min, v_max float64, n_ticks int32, labels []string, keep_default bool) {
	labelsArg, labelsFin := internal.WrapStringList[C.char](labels)
	C.ImPlot_SetupAxisTicks_double(C.ImAxis(axis), C.double(v_min), C.double(v_max), C.int(n_ticks), labelsArg, C.bool(keep_default))

	labelsFin()
}

// SetupAxisTicksdoublePtrV parameter default value hint:
// labels: nullptr
// keep_default: false
func SetupAxisTicksdoublePtrV(axis AxisEnum, values *float64, n_ticks int32, labels []string, keep_default bool) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	labelsArg, labelsFin := internal.WrapStringList[C.char](labels)
	C.ImPlot_SetupAxisTicks_doublePtr(C.ImAxis(axis), valuesArg, C.int(n_ticks), labelsArg, C.bool(keep_default))

	valuesFin()
	labelsFin()
}

func SetupAxisZoomConstraints(axis AxisEnum, z_min, z_max float64) {
	C.ImPlot_SetupAxisZoomConstraints(C.ImAxis(axis), C.double(z_min), C.double(z_max))
}

func SetupFinish() {
	C.ImPlot_SetupFinish()
}

// SetupLegendV parameter default value hint:
// flags: 0
func SetupLegendV(location Location, flags LegendFlags) {
	C.ImPlot_SetupLegend(C.ImPlotLocation(location), C.ImPlotLegendFlags(flags))
}

func SetupLock() {
	C.ImPlot_SetupLock()
}

// SetupMouseTextV parameter default value hint:
// flags: 0
func SetupMouseTextV(location Location, flags MouseTextFlags) {
	C.ImPlot_SetupMouseText(C.ImPlotLocation(location), C.ImPlotMouseTextFlags(flags))
}

// ShowAltLegendV parameter default value hint:
// vertical: true
// size: ImVec2(0,0)
// interactable: true
func ShowAltLegendV(title_id string, vertical bool, size imgui.Vec2, interactable bool) {
	title_idArg, title_idFin := internal.WrapString[C.char](title_id)
	C.ImPlot_ShowAltLegend(title_idArg, C.bool(vertical), internal.ReinterpretCast[C.ImVec2](size.ToC()), C.bool(interactable))

	title_idFin()
}

// ShowAxisContextMenuV parameter default value hint:
// time_allowed: false
func ShowAxisContextMenuV(axis, equal_axis *Axis, time_allowed bool) {
	axisArg, axisFin := axis.Handle()
	equal_axisArg, equal_axisFin := equal_axis.Handle()
	C.ImPlot_ShowAxisContextMenu(internal.ReinterpretCast[*C.ImPlotAxis](axisArg), internal.ReinterpretCast[*C.ImPlotAxis](equal_axisArg), C.bool(time_allowed))

	axisFin()
	equal_axisFin()
}

func ShowColormapSelector(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.ImPlot_ShowColormapSelector(labelArg) == C.bool(true)
}

// ShowDatePickerV parameter default value hint:
// t1: nullptr
// t2: nullptr
func ShowDatePickerV(id string, level *int32, t, t1, t2 *PlotTime) bool {
	idArg, idFin := internal.WrapString[C.char](id)
	levelArg, levelFin := internal.WrapNumberPtr[C.int, int32](level)
	tArg, tFin := internal.Wrap(t)
	t1Arg, t1Fin := internal.Wrap(t1)
	t2Arg, t2Fin := internal.Wrap(t2)

	defer func() {
		idFin()
		levelFin()
		tFin()
		t1Fin()
		t2Fin()
	}()
	return C.ImPlot_ShowDatePicker(idArg, levelArg, internal.ReinterpretCast[*C.ImPlotTime](tArg), internal.ReinterpretCast[*C.ImPlotTime](t1Arg), internal.ReinterpretCast[*C.ImPlotTime](t2Arg)) == C.bool(true)
}

// ShowDemoWindowV parameter default value hint:
// p_open: nullptr
func ShowDemoWindowV(p_open *bool) {
	p_openArg, p_openFin := internal.WrapNumberPtr[C.bool, bool](p_open)
	C.ImPlot_ShowDemoWindow(p_openArg)

	p_openFin()
}

func ShowInputMapSelector(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.ImPlot_ShowInputMapSelector(labelArg) == C.bool(true)
}

func ShowLegendContextMenu(legend *Legend, visible bool) bool {
	legendArg, legendFin := legend.Handle()

	defer func() {
		legendFin()
	}()
	return C.ImPlot_ShowLegendContextMenu(internal.ReinterpretCast[*C.ImPlotLegend](legendArg), C.bool(visible)) == C.bool(true)
}

func ShowLegendEntries(items *ItemGroup, legend_bb imgui.Rect, interactable bool, pad, spacing imgui.Vec2, vertical bool, DrawList *imgui.DrawList) bool {
	itemsArg, itemsFin := items.Handle()
	DrawListArg, DrawListFin := DrawList.Handle()

	defer func() {
		itemsFin()
		DrawListFin()
	}()
	return C.ImPlot_ShowLegendEntries(internal.ReinterpretCast[*C.ImPlotItemGroup](itemsArg), internal.ReinterpretCast[C.ImRect](legend_bb.ToC()), C.bool(interactable), internal.ReinterpretCast[C.ImVec2](pad.ToC()), internal.ReinterpretCast[C.ImVec2](spacing.ToC()), C.bool(vertical), internal.ReinterpretCast[*C.ImDrawList](DrawListArg)) == C.bool(true)
}

// ShowMetricsWindowV parameter default value hint:
// p_popen: nullptr
func ShowMetricsWindowV(p_popen *bool) {
	p_popenArg, p_popenFin := internal.WrapNumberPtr[C.bool, bool](p_popen)
	C.ImPlot_ShowMetricsWindow(p_popenArg)

	p_popenFin()
}

func ShowPlotContextMenu(plot *Plot) {
	plotArg, plotFin := plot.Handle()
	C.ImPlot_ShowPlotContextMenu(internal.ReinterpretCast[*C.ImPlotPlot](plotArg))

	plotFin()
}

// ShowStyleEditorV parameter default value hint:
// ref: nullptr
func ShowStyleEditorV(ref *Style) {
	refArg, refFin := ref.Handle()
	C.ImPlot_ShowStyleEditor(internal.ReinterpretCast[*C.ImPlotStyle](refArg))

	refFin()
}

func ShowStyleSelector(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.ImPlot_ShowStyleSelector(labelArg) == C.bool(true)
}

func ShowSubplotsContextMenu(subplot *Subplot) {
	subplotArg, subplotFin := subplot.Handle()
	C.ImPlot_ShowSubplotsContextMenu(internal.ReinterpretCast[*C.ImPlotSubplot](subplotArg))

	subplotFin()
}

func ShowTimePicker(id string, t *PlotTime) bool {
	idArg, idFin := internal.WrapString[C.char](id)
	tArg, tFin := internal.Wrap(t)

	defer func() {
		idFin()
		tFin()
	}()
	return C.ImPlot_ShowTimePicker(idArg, internal.ReinterpretCast[*C.ImPlotTime](tArg)) == C.bool(true)
}

func ShowUserGuide() {
	C.ImPlot_ShowUserGuide()
}

// StyleColorsAutoV parameter default value hint:
// dst: nullptr
func StyleColorsAutoV(dst *Style) {
	dstArg, dstFin := dst.Handle()
	C.ImPlot_StyleColorsAuto(internal.ReinterpretCast[*C.ImPlotStyle](dstArg))

	dstFin()
}

// StyleColorsClassicV parameter default value hint:
// dst: nullptr
func StyleColorsClassicV(dst *Style) {
	dstArg, dstFin := dst.Handle()
	C.ImPlot_StyleColorsClassic(internal.ReinterpretCast[*C.ImPlotStyle](dstArg))

	dstFin()
}

// StyleColorsDarkV parameter default value hint:
// dst: nullptr
func StyleColorsDarkV(dst *Style) {
	dstArg, dstFin := dst.Handle()
	C.ImPlot_StyleColorsDark(internal.ReinterpretCast[*C.ImPlotStyle](dstArg))

	dstFin()
}

// StyleColorsLightV parameter default value hint:
// dst: nullptr
func StyleColorsLightV(dst *Style) {
	dstArg, dstFin := dst.Handle()
	C.ImPlot_StyleColorsLight(internal.ReinterpretCast[*C.ImPlotStyle](dstArg))

	dstFin()
}

func SubplotNextCell() {
	C.ImPlot_SubplotNextCell()
}

// TagXBoolV parameter default value hint:
// round: false
func TagXBoolV(x float64, col imgui.Vec4, round bool) {
	C.ImPlot_TagX_Bool(C.double(x), internal.ReinterpretCast[C.ImVec4](col.ToC()), C.bool(round))
}

func TagXStr(x float64, col imgui.Vec4, fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_ImPlot_TagX_Str(C.double(x), internal.ReinterpretCast[C.ImVec4](col.ToC()), fmtArg)

	fmtFin()
}

// TagYBoolV parameter default value hint:
// round: false
func TagYBoolV(y float64, col imgui.Vec4, round bool) {
	C.ImPlot_TagY_Bool(C.double(y), internal.ReinterpretCast[C.ImVec4](col.ToC()), C.bool(round))
}

func TagYStr(y float64, col imgui.Vec4, fmt string) {
	fmtArg, fmtFin := internal.WrapString[C.char](fmt)
	C.wrap_ImPlot_TagY_Str(C.double(y), internal.ReinterpretCast[C.ImVec4](col.ToC()), fmtArg)

	fmtFin()
}

func Today() PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.ImPlot_Today(internal.ReinterpretCast[*C.ImPlotTime](pOutArg))

	pOutFin()

	return *pOut
}

func TransformForwardLog10(v float64, noname1 uintptr) float64 {
	return float64(C.wrap_ImPlot_TransformForward_Log10(C.double(v), C.uintptr_t(noname1)))
}

func TransformForwardLogit(v float64, noname1 uintptr) float64 {
	return float64(C.wrap_ImPlot_TransformForward_Logit(C.double(v), C.uintptr_t(noname1)))
}

func TransformForwardSymLog(v float64, noname1 uintptr) float64 {
	return float64(C.wrap_ImPlot_TransformForward_SymLog(C.double(v), C.uintptr_t(noname1)))
}

func TransformInverseLog10(v float64, noname1 uintptr) float64 {
	return float64(C.wrap_ImPlot_TransformInverse_Log10(C.double(v), C.uintptr_t(noname1)))
}

func TransformInverseLogit(v float64, noname1 uintptr) float64 {
	return float64(C.wrap_ImPlot_TransformInverse_Logit(C.double(v), C.uintptr_t(noname1)))
}

func TransformInverseSymLog(v float64, noname1 uintptr) float64 {
	return float64(C.wrap_ImPlot_TransformInverse_SymLog(C.double(v), C.uintptr_t(noname1)))
}

func (self *Axis) SetMax(_max float64) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_SetMax(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.double(_max)) == C.bool(true)
}

func (self *Axis) SetMin(_min float64) bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_SetMin(internal.ReinterpretCast[*C.ImPlotAxis](selfArg), C.double(_min)) == C.bool(true)
}

func AddColormapU32Ptr(name string, cols *uint32, size int32) Colormap {
	nameArg, nameFin := internal.WrapString[C.char](name)
	colsArg, colsFin := internal.WrapNumberPtr[C.ImU32, uint32](cols)

	defer func() {
		nameFin()
		colsFin()
	}()
	return Colormap(C.wrap_ImPlot_AddColormap_U32Ptr(nameArg, colsArg, C.int(size)))
}

func AddColormapVec4Ptr(name string, cols *imgui.Vec4, size int32) Colormap {
	nameArg, nameFin := internal.WrapString[C.char](name)
	colsArg, colsFin := internal.Wrap(cols)

	defer func() {
		nameFin()
		colsFin()
	}()
	return Colormap(C.wrap_ImPlot_AddColormap_Vec4Ptr(nameArg, internal.ReinterpretCast[*C.ImVec4](colsArg), C.int(size)))
}

func AddTextCentered(DrawList *imgui.DrawList, top_center imgui.Vec2, col uint32, text_begin string) {
	DrawListArg, DrawListFin := DrawList.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImPlot_AddTextCentered(internal.ReinterpretCast[*C.ImDrawList](DrawListArg), internal.ReinterpretCast[C.ImVec2](top_center.ToC()), C.ImU32(col), text_beginArg)

	DrawListFin()
	text_beginFin()
}

func AddTextVertical(DrawList *imgui.DrawList, pos imgui.Vec2, col uint32, text_begin string) {
	DrawListArg, DrawListFin := DrawList.Handle()
	text_beginArg, text_beginFin := internal.WrapString[C.char](text_begin)
	C.wrap_ImPlot_AddTextVertical(internal.ReinterpretCast[*C.ImDrawList](DrawListArg), internal.ReinterpretCast[C.ImVec2](pos.ToC()), C.ImU32(col), text_beginArg)

	DrawListFin()
	text_beginFin()
}

func AnnotationBool(x, y float64, col imgui.Vec4, pix_offset imgui.Vec2, clamp bool) {
	C.wrap_ImPlot_Annotation_Bool(C.double(x), C.double(y), internal.ReinterpretCast[C.ImVec4](col.ToC()), internal.ReinterpretCast[C.ImVec2](pix_offset.ToC()), C.bool(clamp))
}

func BeginAlignedPlots(group_id string) bool {
	group_idArg, group_idFin := internal.WrapString[C.char](group_id)

	defer func() {
		group_idFin()
	}()
	return C.wrap_ImPlot_BeginAlignedPlots(group_idArg) == C.bool(true)
}

func BeginDragDropSourceAxis(axis AxisEnum) bool {
	return C.wrap_ImPlot_BeginDragDropSourceAxis(C.ImAxis(axis)) == C.bool(true)
}

func BeginDragDropSourceItem(label_id string) bool {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		label_idFin()
	}()
	return C.wrap_ImPlot_BeginDragDropSourceItem(label_idArg) == C.bool(true)
}

func BeginDragDropSourcePlot() bool {
	return C.wrap_ImPlot_BeginDragDropSourcePlot() == C.bool(true)
}

func BeginItem(label_id string) bool {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		label_idFin()
	}()
	return C.wrap_ImPlot_BeginItem(label_idArg) == C.bool(true)
}

func BeginLegendPopup(label_id string) bool {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		label_idFin()
	}()
	return C.wrap_ImPlot_BeginLegendPopup(label_idArg) == C.bool(true)
}

func BeginPlot(title_id string) bool {
	title_idArg, title_idFin := internal.WrapString[C.char](title_id)

	defer func() {
		title_idFin()
	}()
	return C.wrap_ImPlot_BeginPlot(title_idArg) == C.bool(true)
}

func BeginSubplots(title_id string, rows, cols int32, size imgui.Vec2) bool {
	title_idArg, title_idFin := internal.WrapString[C.char](title_id)

	defer func() {
		title_idFin()
	}()
	return C.wrap_ImPlot_BeginSubplots(title_idArg, C.int(rows), C.int(cols), internal.ReinterpretCast[C.ImVec2](size.ToC())) == C.bool(true)
}

func BustColorCache() {
	C.wrap_ImPlot_BustColorCache()
}

func ColormapButton(label string) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)

	defer func() {
		labelFin()
	}()
	return C.wrap_ImPlot_ColormapButton(labelArg) == C.bool(true)
}

func ColormapScale(label string, scale_min, scale_max float64) {
	labelArg, labelFin := internal.WrapString[C.char](label)
	C.wrap_ImPlot_ColormapScale(labelArg, C.double(scale_min), C.double(scale_max))

	labelFin()
}

func ColormapSlider(label string, t *float32) bool {
	labelArg, labelFin := internal.WrapString[C.char](label)
	tArg, tFin := internal.WrapNumberPtr[C.float, float32](t)

	defer func() {
		labelFin()
		tFin()
	}()
	return C.wrap_ImPlot_ColormapSlider(labelArg, tArg) == C.bool(true)
}

func DestroyContext() {
	C.wrap_ImPlot_DestroyContext()
}

func DragLineX(id int32, x *float64, col imgui.Vec4) bool {
	xArg, xFin := internal.WrapNumberPtr[C.double, float64](x)

	defer func() {
		xFin()
	}()
	return C.wrap_ImPlot_DragLineX(C.int(id), xArg, internal.ReinterpretCast[C.ImVec4](col.ToC())) == C.bool(true)
}

func DragLineY(id int32, y *float64, col imgui.Vec4) bool {
	yArg, yFin := internal.WrapNumberPtr[C.double, float64](y)

	defer func() {
		yFin()
	}()
	return C.wrap_ImPlot_DragLineY(C.int(id), yArg, internal.ReinterpretCast[C.ImVec4](col.ToC())) == C.bool(true)
}

func DragPoint(id int32, x, y *float64, col imgui.Vec4) bool {
	xArg, xFin := internal.WrapNumberPtr[C.double, float64](x)
	yArg, yFin := internal.WrapNumberPtr[C.double, float64](y)

	defer func() {
		xFin()
		yFin()
	}()
	return C.wrap_ImPlot_DragPoint(C.int(id), xArg, yArg, internal.ReinterpretCast[C.ImVec4](col.ToC())) == C.bool(true)
}

func DragRect(id int32, x1, y1, x2, y2 *float64, col imgui.Vec4) bool {
	x1Arg, x1Fin := internal.WrapNumberPtr[C.double, float64](x1)
	y1Arg, y1Fin := internal.WrapNumberPtr[C.double, float64](y1)
	x2Arg, x2Fin := internal.WrapNumberPtr[C.double, float64](x2)
	y2Arg, y2Fin := internal.WrapNumberPtr[C.double, float64](y2)

	defer func() {
		x1Fin()
		y1Fin()
		x2Fin()
		y2Fin()
	}()
	return C.wrap_ImPlot_DragRect(C.int(id), x1Arg, y1Arg, x2Arg, y2Arg, internal.ReinterpretCast[C.ImVec4](col.ToC())) == C.bool(true)
}

func GetColormapColor(idx int32) imgui.Vec4 {
	pOut := new(imgui.Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImPlot_GetColormapColor(internal.ReinterpretCast[*C.ImVec4](pOutArg), C.int(idx))

	pOutFin()

	return *pOut
}

func GetColormapSize() int32 {
	return int32(C.wrap_ImPlot_GetColormapSize())
}

func GetLocationPos(outer_rect imgui.Rect, inner_size imgui.Vec2, location Location) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImPlot_GetLocationPos(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImRect](outer_rect.ToC()), internal.ReinterpretCast[C.ImVec2](inner_size.ToC()), C.ImPlotLocation(location))

	pOutFin()

	return *pOut
}

func GetPlotLimits() Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := pOut.Handle()

	C.wrap_ImPlot_GetPlotLimits(internal.ReinterpretCast[*C.ImPlotRect](pOutArg))

	pOutFin()

	return *pOut
}

func GetPlotMousePos() PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImPlot_GetPlotMousePos(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg))

	pOutFin()

	return *pOut
}

func GetPlotSelection() Rect {
	pOut := new(Rect)
	pOutArg, pOutFin := pOut.Handle()

	C.wrap_ImPlot_GetPlotSelection(internal.ReinterpretCast[*C.ImPlotRect](pOutArg))

	pOutFin()

	return *pOut
}

func HideNextItem() {
	C.wrap_ImPlot_HideNextItem()
}

func ImAlmostEqual(v1, v2 float64) bool {
	return C.wrap_ImPlot_ImAlmostEqual(C.double(v1), C.double(v2)) == C.bool(true)
}

func LabelAxisValue(axis Axis, value float64, buff string, size int32) {
	axisArg, axisFin := axis.C()
	buffArg, buffFin := internal.WrapString[C.char](buff)
	C.wrap_ImPlot_LabelAxisValue(internal.ReinterpretCast[C.ImPlotAxis](axisArg), C.double(value), buffArg, C.int(size))

	axisFin()
	buffFin()
}

func MakeTime(year int32) PlotTime {
	pOut := new(PlotTime)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImPlot_MakeTime(internal.ReinterpretCast[*C.ImPlotTime](pOutArg), C.int(year))

	pOutFin()

	return *pOut
}

func MapInputDefault() {
	C.wrap_ImPlot_MapInputDefault()
}

func MapInputReverse() {
	C.wrap_ImPlot_MapInputReverse()
}

func PixelsToPlotFloat(x, y float32) PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImPlot_PixelsToPlot_Float(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), C.float(x), C.float(y))

	pOutFin()

	return *pOut
}

func PixelsToPlotVec2(pix imgui.Vec2) PlotPoint {
	pOut := new(PlotPoint)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImPlot_PixelsToPlot_Vec2(internal.ReinterpretCast[*C.ImPlotPoint](pOutArg), internal.ReinterpretCast[C.ImVec2](pix.ToC()))

	pOutFin()

	return *pOut
}

func PlotBarGroupsFloatPtr(label_ids []string, values *float32, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotBarGroups_FloatPtr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarGroupsS16Ptr(label_ids []string, values *int16, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotBarGroups_S16Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarGroupsS32Ptr(label_ids []string, values *int32, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotBarGroups_S32Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarGroupsS64Ptr(label_ids []string, values *int64, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotBarGroups_S64Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarGroupsS8Ptr(label_ids []string, values *int8, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotBarGroups_S8Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarGroupsU16Ptr(label_ids []string, values *uint16, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotBarGroups_U16Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarGroupsU32Ptr(label_ids []string, values *uint32, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotBarGroups_U32Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarGroupsU64Ptr(label_ids []string, values *uint64, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotBarGroups_U64Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarGroupsU8Ptr(label_ids []string, values *byte, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotBarGroups_U8Ptr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarGroupsdoublePtr(label_ids []string, values *float64, item_count, group_count int32) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotBarGroups_doublePtr(label_idsArg, valuesArg, C.int(item_count), C.int(group_count))

	label_idsFin()
	valuesFin()
}

func PlotBarsFloatPtrFloatPtr(label_id string, xs, ys *float32, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.wrap_ImPlot_PlotBars_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotBarsFloatPtrInt(label_id string, values *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotBars_FloatPtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsS16PtrInt(label_id string, values *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotBars_S16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsS16PtrS16Ptr(label_id string, xs, ys *int16, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.wrap_ImPlot_PlotBars_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotBarsS32PtrInt(label_id string, values *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotBars_S32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsS32PtrS32Ptr(label_id string, xs, ys *int32, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.wrap_ImPlot_PlotBars_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotBarsS64PtrInt(label_id string, values *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotBars_S64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsS64PtrS64Ptr(label_id string, xs, ys *int64, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.wrap_ImPlot_PlotBars_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotBarsS8PtrInt(label_id string, values *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotBars_S8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsS8PtrS8Ptr(label_id string, xs, ys *int8, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.wrap_ImPlot_PlotBars_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotBarsU16PtrInt(label_id string, values *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotBars_U16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsU16PtrU16Ptr(label_id string, xs, ys *uint16, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.wrap_ImPlot_PlotBars_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotBarsU32PtrInt(label_id string, values *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotBars_U32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsU32PtrU32Ptr(label_id string, xs, ys *uint32, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.wrap_ImPlot_PlotBars_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotBarsU64PtrInt(label_id string, values *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotBars_U64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsU64PtrU64Ptr(label_id string, xs, ys *uint64, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.wrap_ImPlot_PlotBars_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotBarsU8PtrInt(label_id string, values *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotBars_U8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsU8PtrU8Ptr(label_id string, xs, ys *byte, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.wrap_ImPlot_PlotBars_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotBarsdoublePtrInt(label_id string, values *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotBars_doublePtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotBarsdoublePtrdoublePtr(label_id string, xs, ys *float64, count int32, bar_size float64) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.wrap_ImPlot_PlotBars_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count), C.double(bar_size))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitalFloatPtr(label_id string, xs, ys *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.wrap_ImPlot_PlotDigital_FloatPtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitalS16Ptr(label_id string, xs, ys *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.wrap_ImPlot_PlotDigital_S16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitalS32Ptr(label_id string, xs, ys *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.wrap_ImPlot_PlotDigital_S32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitalS64Ptr(label_id string, xs, ys *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.wrap_ImPlot_PlotDigital_S64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitalS8Ptr(label_id string, xs, ys *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.wrap_ImPlot_PlotDigital_S8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitalU16Ptr(label_id string, xs, ys *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.wrap_ImPlot_PlotDigital_U16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitalU32Ptr(label_id string, xs, ys *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.wrap_ImPlot_PlotDigital_U32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitalU64Ptr(label_id string, xs, ys *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.wrap_ImPlot_PlotDigital_U64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitalU8Ptr(label_id string, xs, ys *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.wrap_ImPlot_PlotDigital_U8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDigitaldoublePtr(label_id string, xs, ys *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.wrap_ImPlot_PlotDigital_doublePtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotDummy(label_id string) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	C.wrap_ImPlot_PlotDummy(label_idArg)

	label_idFin()
}

func PlotErrorBarsFloatPtrFloatPtrFloatPtrFloatPtr(label_id string, xs, ys, neg, pos *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	negArg, negFin := internal.WrapNumberPtr[C.float, float32](neg)
	posArg, posFin := internal.WrapNumberPtr[C.float, float32](pos)
	C.wrap_ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotErrorBarsFloatPtrFloatPtrFloatPtrInt(label_id string, xs, ys, err *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	errArg, errFin := internal.WrapNumberPtr[C.float, float32](err)
	C.wrap_ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsS16PtrS16PtrS16PtrInt(label_id string, xs, ys, err *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImS16, int16](err)
	C.wrap_ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsS16PtrS16PtrS16PtrS16Ptr(label_id string, xs, ys, neg, pos *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImS16, int16](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImS16, int16](pos)
	C.wrap_ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotErrorBarsS32PtrS32PtrS32PtrInt(label_id string, xs, ys, err *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImS32, int32](err)
	C.wrap_ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsS32PtrS32PtrS32PtrS32Ptr(label_id string, xs, ys, neg, pos *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImS32, int32](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImS32, int32](pos)
	C.wrap_ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotErrorBarsS64PtrS64PtrS64PtrInt(label_id string, xs, ys, err *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImS64, int64](err)
	C.wrap_ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsS64PtrS64PtrS64PtrS64Ptr(label_id string, xs, ys, neg, pos *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImS64, int64](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImS64, int64](pos)
	C.wrap_ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotErrorBarsS8PtrS8PtrS8PtrInt(label_id string, xs, ys, err *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImS8, int8](err)
	C.wrap_ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsS8PtrS8PtrS8PtrS8Ptr(label_id string, xs, ys, neg, pos *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImS8, int8](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImS8, int8](pos)
	C.wrap_ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotErrorBarsU16PtrU16PtrU16PtrInt(label_id string, xs, ys, err *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImU16, uint16](err)
	C.wrap_ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsU16PtrU16PtrU16PtrU16Ptr(label_id string, xs, ys, neg, pos *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImU16, uint16](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImU16, uint16](pos)
	C.wrap_ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotErrorBarsU32PtrU32PtrU32PtrInt(label_id string, xs, ys, err *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImU32, uint32](err)
	C.wrap_ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsU32PtrU32PtrU32PtrU32Ptr(label_id string, xs, ys, neg, pos *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImU32, uint32](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImU32, uint32](pos)
	C.wrap_ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotErrorBarsU64PtrU64PtrU64PtrInt(label_id string, xs, ys, err *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImU64, uint64](err)
	C.wrap_ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsU64PtrU64PtrU64PtrU64Ptr(label_id string, xs, ys, neg, pos *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImU64, uint64](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImU64, uint64](pos)
	C.wrap_ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotErrorBarsU8PtrU8PtrU8PtrInt(label_id string, xs, ys, err *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	errArg, errFin := internal.WrapNumberPtr[C.ImU8, byte](err)
	C.wrap_ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsU8PtrU8PtrU8PtrU8Ptr(label_id string, xs, ys, neg, pos *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	negArg, negFin := internal.WrapNumberPtr[C.ImU8, byte](neg)
	posArg, posFin := internal.WrapNumberPtr[C.ImU8, byte](pos)
	C.wrap_ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotErrorBarsdoublePtrdoublePtrdoublePtrInt(label_id string, xs, ys, err *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	errArg, errFin := internal.WrapNumberPtr[C.double, float64](err)
	C.wrap_ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(label_idArg, xsArg, ysArg, errArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	errFin()
}

func PlotErrorBarsdoublePtrdoublePtrdoublePtrdoublePtr(label_id string, xs, ys, neg, pos *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	negArg, negFin := internal.WrapNumberPtr[C.double, float64](neg)
	posArg, posFin := internal.WrapNumberPtr[C.double, float64](pos)
	C.wrap_ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(label_idArg, xsArg, ysArg, negArg, posArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
	negFin()
	posFin()
}

func PlotHeatmapFloatPtr(label_id string, values *float32, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotHeatmap_FloatPtr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHeatmapS16Ptr(label_id string, values *int16, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotHeatmap_S16Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHeatmapS32Ptr(label_id string, values *int32, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotHeatmap_S32Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHeatmapS64Ptr(label_id string, values *int64, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotHeatmap_S64Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHeatmapS8Ptr(label_id string, values *int8, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotHeatmap_S8Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHeatmapU16Ptr(label_id string, values *uint16, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotHeatmap_U16Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHeatmapU32Ptr(label_id string, values *uint32, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotHeatmap_U32Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHeatmapU64Ptr(label_id string, values *uint64, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotHeatmap_U64Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHeatmapU8Ptr(label_id string, values *byte, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotHeatmap_U8Ptr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHeatmapdoublePtr(label_id string, values *float64, rows, cols int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotHeatmap_doublePtr(label_idArg, valuesArg, C.int(rows), C.int(cols))

	label_idFin()
	valuesFin()
}

func PlotHistogram2DFloatPtr(label_id string, xs, ys *float32, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_FloatPtr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogram2DS16Ptr(label_id string, xs, ys *int16, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_S16Ptr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogram2DS32Ptr(label_id string, xs, ys *int32, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_S32Ptr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogram2DS64Ptr(label_id string, xs, ys *int64, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_S64Ptr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogram2DS8Ptr(label_id string, xs, ys *int8, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_S8Ptr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogram2DU16Ptr(label_id string, xs, ys *uint16, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_U16Ptr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogram2DU32Ptr(label_id string, xs, ys *uint32, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_U32Ptr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogram2DU64Ptr(label_id string, xs, ys *uint64, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_U64Ptr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogram2DU8Ptr(label_id string, xs, ys *byte, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_U8Ptr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogram2DdoublePtr(label_id string, xs, ys *float64, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)

	defer func() {
		label_idFin()
		xsFin()
		ysFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram2D_doublePtr(label_idArg, xsArg, ysArg, C.int(count)))
}

func PlotHistogramFloatPtr(label_id string, values *float32, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_FloatPtr(label_idArg, valuesArg, C.int(count)))
}

func PlotHistogramS16Ptr(label_id string, values *int16, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_S16Ptr(label_idArg, valuesArg, C.int(count)))
}

func PlotHistogramS32Ptr(label_id string, values *int32, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_S32Ptr(label_idArg, valuesArg, C.int(count)))
}

func PlotHistogramS64Ptr(label_id string, values *int64, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_S64Ptr(label_idArg, valuesArg, C.int(count)))
}

func PlotHistogramS8Ptr(label_id string, values *int8, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_S8Ptr(label_idArg, valuesArg, C.int(count)))
}

func PlotHistogramU16Ptr(label_id string, values *uint16, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_U16Ptr(label_idArg, valuesArg, C.int(count)))
}

func PlotHistogramU32Ptr(label_id string, values *uint32, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_U32Ptr(label_idArg, valuesArg, C.int(count)))
}

func PlotHistogramU64Ptr(label_id string, values *uint64, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_U64Ptr(label_idArg, valuesArg, C.int(count)))
}

func PlotHistogramU8Ptr(label_id string, values *byte, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_U8Ptr(label_idArg, valuesArg, C.int(count)))
}

func PlotHistogramdoublePtr(label_id string, values *float64, count int32) float64 {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)

	defer func() {
		label_idFin()
		valuesFin()
	}()
	return float64(C.wrap_ImPlot_PlotHistogram_doublePtr(label_idArg, valuesArg, C.int(count)))
}

func PlotImage(label_id string, tex_ref imgui.TextureRef, bounds_min, bounds_max PlotPoint) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	tex_refArg, tex_refFin := tex_ref.C()
	C.wrap_ImPlot_PlotImage(label_idArg, internal.ReinterpretCast[C.ImTextureRef](tex_refArg), internal.ReinterpretCast[C.ImPlotPoint](bounds_min.ToC()), internal.ReinterpretCast[C.ImPlotPoint](bounds_max.ToC()))

	label_idFin()
	tex_refFin()
}

func PlotInfLinesFloatPtr(label_id string, values *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotInfLines_FloatPtr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotInfLinesS16Ptr(label_id string, values *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotInfLines_S16Ptr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotInfLinesS32Ptr(label_id string, values *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotInfLines_S32Ptr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotInfLinesS64Ptr(label_id string, values *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotInfLines_S64Ptr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotInfLinesS8Ptr(label_id string, values *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotInfLines_S8Ptr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotInfLinesU16Ptr(label_id string, values *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotInfLines_U16Ptr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotInfLinesU32Ptr(label_id string, values *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotInfLines_U32Ptr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotInfLinesU64Ptr(label_id string, values *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotInfLines_U64Ptr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotInfLinesU8Ptr(label_id string, values *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotInfLines_U8Ptr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotInfLinesdoublePtr(label_id string, values *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotInfLines_doublePtr(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineFloatPtrFloatPtr(label_id string, xs, ys *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.wrap_ImPlot_PlotLine_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotLineFloatPtrInt(label_id string, values *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotLine_FloatPtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineS16PtrInt(label_id string, values *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotLine_S16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineS16PtrS16Ptr(label_id string, xs, ys *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.wrap_ImPlot_PlotLine_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotLineS32PtrInt(label_id string, values *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotLine_S32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineS32PtrS32Ptr(label_id string, xs, ys *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.wrap_ImPlot_PlotLine_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotLineS64PtrInt(label_id string, values *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotLine_S64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineS64PtrS64Ptr(label_id string, xs, ys *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.wrap_ImPlot_PlotLine_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotLineS8PtrInt(label_id string, values *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotLine_S8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineS8PtrS8Ptr(label_id string, xs, ys *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.wrap_ImPlot_PlotLine_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotLineU16PtrInt(label_id string, values *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotLine_U16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineU16PtrU16Ptr(label_id string, xs, ys *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.wrap_ImPlot_PlotLine_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotLineU32PtrInt(label_id string, values *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotLine_U32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineU32PtrU32Ptr(label_id string, xs, ys *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.wrap_ImPlot_PlotLine_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotLineU64PtrInt(label_id string, values *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotLine_U64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineU64PtrU64Ptr(label_id string, xs, ys *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.wrap_ImPlot_PlotLine_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotLineU8PtrInt(label_id string, values *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotLine_U8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLineU8PtrU8Ptr(label_id string, xs, ys *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.wrap_ImPlot_PlotLine_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotLinedoublePtrInt(label_id string, values *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotLine_doublePtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotLinedoublePtrdoublePtr(label_id string, xs, ys *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.wrap_ImPlot_PlotLine_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotPieChartFloatPtrPlotFormatter(label_ids []string, values *float32, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_FloatPtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartFloatPtrStr(label_ids []string, values *float32, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotPieChart_FloatPtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotPieChartS16PtrPlotFormatter(label_ids []string, values *int16, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_S16PtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartS16PtrStr(label_ids []string, values *int16, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotPieChart_S16PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotPieChartS32PtrPlotFormatter(label_ids []string, values *int32, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_S32PtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartS32PtrStr(label_ids []string, values *int32, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotPieChart_S32PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotPieChartS64PtrPlotFormatter(label_ids []string, values *int64, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_S64PtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartS64PtrStr(label_ids []string, values *int64, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotPieChart_S64PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotPieChartS8PtrPlotFormatter(label_ids []string, values *int8, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_S8PtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartS8PtrStr(label_ids []string, values *int8, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotPieChart_S8PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotPieChartU16PtrPlotFormatter(label_ids []string, values *uint16, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_U16PtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartU16PtrStr(label_ids []string, values *uint16, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotPieChart_U16PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotPieChartU32PtrPlotFormatter(label_ids []string, values *uint32, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_U32PtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartU32PtrStr(label_ids []string, values *uint32, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotPieChart_U32PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotPieChartU64PtrPlotFormatter(label_ids []string, values *uint64, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_U64PtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartU64PtrStr(label_ids []string, values *uint64, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotPieChart_U64PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotPieChartU8PtrPlotFormatter(label_ids []string, values *byte, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_U8PtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartU8PtrStr(label_ids []string, values *byte, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotPieChart_U8PtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotPieChartdoublePtrPlotFormatter(label_ids []string, values *float64, count int32, x, y, radius float64, fmt Formatter) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	fmtArg, fmtFin := fmt.C()
	C.wrap_ImPlot_PlotPieChart_doublePtrPlotFormatter(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius), internal.ReinterpretCast[C.ImPlotFormatter](fmtArg))

	label_idsFin()
	valuesFin()
	fmtFin()
}

func PlotPieChartdoublePtrStr(label_ids []string, values *float64, count int32, x, y, radius float64) {
	label_idsArg, label_idsFin := internal.WrapStringList[C.char](label_ids)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotPieChart_doublePtrStr(label_idsArg, valuesArg, C.int(count), C.double(x), C.double(y), C.double(radius))

	label_idsFin()
	valuesFin()
}

func PlotScatterFloatPtrFloatPtr(label_id string, xs, ys *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.wrap_ImPlot_PlotScatter_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotScatterFloatPtrInt(label_id string, values *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotScatter_FloatPtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterS16PtrInt(label_id string, values *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotScatter_S16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterS16PtrS16Ptr(label_id string, xs, ys *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.wrap_ImPlot_PlotScatter_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotScatterS32PtrInt(label_id string, values *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotScatter_S32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterS32PtrS32Ptr(label_id string, xs, ys *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.wrap_ImPlot_PlotScatter_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotScatterS64PtrInt(label_id string, values *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotScatter_S64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterS64PtrS64Ptr(label_id string, xs, ys *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.wrap_ImPlot_PlotScatter_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotScatterS8PtrInt(label_id string, values *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotScatter_S8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterS8PtrS8Ptr(label_id string, xs, ys *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.wrap_ImPlot_PlotScatter_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotScatterU16PtrInt(label_id string, values *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotScatter_U16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterU16PtrU16Ptr(label_id string, xs, ys *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.wrap_ImPlot_PlotScatter_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotScatterU32PtrInt(label_id string, values *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotScatter_U32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterU32PtrU32Ptr(label_id string, xs, ys *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.wrap_ImPlot_PlotScatter_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotScatterU64PtrInt(label_id string, values *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotScatter_U64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterU64PtrU64Ptr(label_id string, xs, ys *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.wrap_ImPlot_PlotScatter_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotScatterU8PtrInt(label_id string, values *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotScatter_U8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterU8PtrU8Ptr(label_id string, xs, ys *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.wrap_ImPlot_PlotScatter_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotScatterdoublePtrInt(label_id string, values *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotScatter_doublePtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotScatterdoublePtrdoublePtr(label_id string, xs, ys *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.wrap_ImPlot_PlotScatter_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedFloatPtrFloatPtrFloatPtr(label_id string, xs, ys1, ys2 *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.float, float32](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.float, float32](ys2)
	C.wrap_ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotShadedFloatPtrFloatPtrInt(label_id string, xs, ys *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.wrap_ImPlot_PlotShaded_FloatPtrFloatPtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedFloatPtrInt(label_id string, values *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotShaded_FloatPtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadedS16PtrInt(label_id string, values *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotShaded_S16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadedS16PtrS16PtrInt(label_id string, xs, ys *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.wrap_ImPlot_PlotShaded_S16PtrS16PtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedS16PtrS16PtrS16Ptr(label_id string, xs, ys1, ys2 *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImS16, int16](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImS16, int16](ys2)
	C.wrap_ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotShadedS32PtrInt(label_id string, values *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotShaded_S32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadedS32PtrS32PtrInt(label_id string, xs, ys *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.wrap_ImPlot_PlotShaded_S32PtrS32PtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedS32PtrS32PtrS32Ptr(label_id string, xs, ys1, ys2 *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImS32, int32](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImS32, int32](ys2)
	C.wrap_ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotShadedS64PtrInt(label_id string, values *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotShaded_S64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadedS64PtrS64PtrInt(label_id string, xs, ys *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.wrap_ImPlot_PlotShaded_S64PtrS64PtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedS64PtrS64PtrS64Ptr(label_id string, xs, ys1, ys2 *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImS64, int64](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImS64, int64](ys2)
	C.wrap_ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotShadedS8PtrInt(label_id string, values *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotShaded_S8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadedS8PtrS8PtrInt(label_id string, xs, ys *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.wrap_ImPlot_PlotShaded_S8PtrS8PtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedS8PtrS8PtrS8Ptr(label_id string, xs, ys1, ys2 *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImS8, int8](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImS8, int8](ys2)
	C.wrap_ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotShadedU16PtrInt(label_id string, values *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotShaded_U16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadedU16PtrU16PtrInt(label_id string, xs, ys *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.wrap_ImPlot_PlotShaded_U16PtrU16PtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedU16PtrU16PtrU16Ptr(label_id string, xs, ys1, ys2 *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImU16, uint16](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImU16, uint16](ys2)
	C.wrap_ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotShadedU32PtrInt(label_id string, values *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotShaded_U32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadedU32PtrU32PtrInt(label_id string, xs, ys *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.wrap_ImPlot_PlotShaded_U32PtrU32PtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedU32PtrU32PtrU32Ptr(label_id string, xs, ys1, ys2 *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImU32, uint32](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImU32, uint32](ys2)
	C.wrap_ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotShadedU64PtrInt(label_id string, values *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotShaded_U64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadedU64PtrU64PtrInt(label_id string, xs, ys *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.wrap_ImPlot_PlotShaded_U64PtrU64PtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedU64PtrU64PtrU64Ptr(label_id string, xs, ys1, ys2 *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImU64, uint64](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImU64, uint64](ys2)
	C.wrap_ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotShadedU8PtrInt(label_id string, values *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotShaded_U8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadedU8PtrU8PtrInt(label_id string, xs, ys *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.wrap_ImPlot_PlotShaded_U8PtrU8PtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadedU8PtrU8PtrU8Ptr(label_id string, xs, ys1, ys2 *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.ImU8, byte](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.ImU8, byte](ys2)
	C.wrap_ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotShadeddoublePtrInt(label_id string, values *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotShaded_doublePtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotShadeddoublePtrdoublePtrInt(label_id string, xs, ys *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.wrap_ImPlot_PlotShaded_doublePtrdoublePtrInt(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotShadeddoublePtrdoublePtrdoublePtr(label_id string, xs, ys1, ys2 *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ys1Arg, ys1Fin := internal.WrapNumberPtr[C.double, float64](ys1)
	ys2Arg, ys2Fin := internal.WrapNumberPtr[C.double, float64](ys2)
	C.wrap_ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(label_idArg, xsArg, ys1Arg, ys2Arg, C.int(count))

	label_idFin()
	xsFin()
	ys1Fin()
	ys2Fin()
}

func PlotStairsFloatPtrFloatPtr(label_id string, xs, ys *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.wrap_ImPlot_PlotStairs_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStairsFloatPtrInt(label_id string, values *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotStairs_FloatPtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsS16PtrInt(label_id string, values *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotStairs_S16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsS16PtrS16Ptr(label_id string, xs, ys *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.wrap_ImPlot_PlotStairs_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStairsS32PtrInt(label_id string, values *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotStairs_S32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsS32PtrS32Ptr(label_id string, xs, ys *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.wrap_ImPlot_PlotStairs_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStairsS64PtrInt(label_id string, values *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotStairs_S64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsS64PtrS64Ptr(label_id string, xs, ys *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.wrap_ImPlot_PlotStairs_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStairsS8PtrInt(label_id string, values *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotStairs_S8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsS8PtrS8Ptr(label_id string, xs, ys *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.wrap_ImPlot_PlotStairs_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStairsU16PtrInt(label_id string, values *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotStairs_U16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsU16PtrU16Ptr(label_id string, xs, ys *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.wrap_ImPlot_PlotStairs_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStairsU32PtrInt(label_id string, values *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotStairs_U32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsU32PtrU32Ptr(label_id string, xs, ys *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.wrap_ImPlot_PlotStairs_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStairsU64PtrInt(label_id string, values *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotStairs_U64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsU64PtrU64Ptr(label_id string, xs, ys *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.wrap_ImPlot_PlotStairs_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStairsU8PtrInt(label_id string, values *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotStairs_U8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsU8PtrU8Ptr(label_id string, xs, ys *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.wrap_ImPlot_PlotStairs_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStairsdoublePtrInt(label_id string, values *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotStairs_doublePtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStairsdoublePtrdoublePtr(label_id string, xs, ys *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.wrap_ImPlot_PlotStairs_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsFloatPtrFloatPtr(label_id string, xs, ys *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.float, float32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.float, float32](ys)
	C.wrap_ImPlot_PlotStems_FloatPtrFloatPtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsFloatPtrInt(label_id string, values *float32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.float, float32](values)
	C.wrap_ImPlot_PlotStems_FloatPtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsS16PtrInt(label_id string, values *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS16, int16](values)
	C.wrap_ImPlot_PlotStems_S16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsS16PtrS16Ptr(label_id string, xs, ys *int16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS16, int16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS16, int16](ys)
	C.wrap_ImPlot_PlotStems_S16PtrS16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsS32PtrInt(label_id string, values *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS32, int32](values)
	C.wrap_ImPlot_PlotStems_S32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsS32PtrS32Ptr(label_id string, xs, ys *int32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS32, int32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS32, int32](ys)
	C.wrap_ImPlot_PlotStems_S32PtrS32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsS64PtrInt(label_id string, values *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS64, int64](values)
	C.wrap_ImPlot_PlotStems_S64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsS64PtrS64Ptr(label_id string, xs, ys *int64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS64, int64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS64, int64](ys)
	C.wrap_ImPlot_PlotStems_S64PtrS64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsS8PtrInt(label_id string, values *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImS8, int8](values)
	C.wrap_ImPlot_PlotStems_S8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsS8PtrS8Ptr(label_id string, xs, ys *int8, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImS8, int8](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImS8, int8](ys)
	C.wrap_ImPlot_PlotStems_S8PtrS8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsU16PtrInt(label_id string, values *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU16, uint16](values)
	C.wrap_ImPlot_PlotStems_U16PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsU16PtrU16Ptr(label_id string, xs, ys *uint16, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU16, uint16](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU16, uint16](ys)
	C.wrap_ImPlot_PlotStems_U16PtrU16Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsU32PtrInt(label_id string, values *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU32, uint32](values)
	C.wrap_ImPlot_PlotStems_U32PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsU32PtrU32Ptr(label_id string, xs, ys *uint32, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU32, uint32](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU32, uint32](ys)
	C.wrap_ImPlot_PlotStems_U32PtrU32Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsU64PtrInt(label_id string, values *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU64, uint64](values)
	C.wrap_ImPlot_PlotStems_U64PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsU64PtrU64Ptr(label_id string, xs, ys *uint64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU64, uint64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU64, uint64](ys)
	C.wrap_ImPlot_PlotStems_U64PtrU64Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsU8PtrInt(label_id string, values *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.ImU8, byte](values)
	C.wrap_ImPlot_PlotStems_U8PtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsU8PtrU8Ptr(label_id string, xs, ys *byte, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.ImU8, byte](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.ImU8, byte](ys)
	C.wrap_ImPlot_PlotStems_U8PtrU8Ptr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotStemsdoublePtrInt(label_id string, values *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_PlotStems_doublePtrInt(label_idArg, valuesArg, C.int(count))

	label_idFin()
	valuesFin()
}

func PlotStemsdoublePtrdoublePtr(label_id string, xs, ys *float64, count int32) {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)
	xsArg, xsFin := internal.WrapNumberPtr[C.double, float64](xs)
	ysArg, ysFin := internal.WrapNumberPtr[C.double, float64](ys)
	C.wrap_ImPlot_PlotStems_doublePtrdoublePtr(label_idArg, xsArg, ysArg, C.int(count))

	label_idFin()
	xsFin()
	ysFin()
}

func PlotText(text string, x, y float64) {
	textArg, textFin := internal.WrapString[C.char](text)
	C.wrap_ImPlot_PlotText(textArg, C.double(x), C.double(y))

	textFin()
}

func PlotToPixelsPlotPoInt(plt PlotPoint) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImPlot_PlotToPixels_PlotPoInt(internal.ReinterpretCast[*C.ImVec2](pOutArg), internal.ReinterpretCast[C.ImPlotPoint](plt.ToC()))

	pOutFin()

	return *pOut
}

func PlotToPixelsdouble(x, y float64) imgui.Vec2 {
	pOut := new(imgui.Vec2)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImPlot_PlotToPixels_double(internal.ReinterpretCast[*C.ImVec2](pOutArg), C.double(x), C.double(y))

	pOutFin()

	return *pOut
}

func PopColormap() {
	C.wrap_ImPlot_PopColormap()
}

func PopStyleColor() {
	C.wrap_ImPlot_PopStyleColor()
}

func PopStyleVar() {
	C.wrap_ImPlot_PopStyleVar()
}

func PushPlotClipRect() {
	C.wrap_ImPlot_PushPlotClipRect()
}

func RegisterOrGetItem(label_id string, flags ItemFlags) *Item {
	label_idArg, label_idFin := internal.WrapString[C.char](label_id)

	defer func() {
		label_idFin()
	}()
	return NewItemFromC(C.wrap_ImPlot_RegisterOrGetItem(label_idArg, C.ImPlotItemFlags(flags)))
}

func SampleColormap(t float32) imgui.Vec4 {
	pOut := new(imgui.Vec4)
	pOutArg, pOutFin := internal.Wrap(pOut)

	C.wrap_ImPlot_SampleColormap(internal.ReinterpretCast[*C.ImVec4](pOutArg), C.float(t))

	pOutFin()

	return *pOut
}

func SetNextAxesLimits(x_min, x_max, y_min, y_max float64) {
	C.wrap_ImPlot_SetNextAxesLimits(C.double(x_min), C.double(x_max), C.double(y_min), C.double(y_max))
}

func SetNextAxisLimits(axis AxisEnum, v_min, v_max float64) {
	C.wrap_ImPlot_SetNextAxisLimits(C.ImAxis(axis), C.double(v_min), C.double(v_max))
}

func SetNextErrorBarStyle() {
	C.wrap_ImPlot_SetNextErrorBarStyle()
}

func SetNextFillStyle() {
	C.wrap_ImPlot_SetNextFillStyle()
}

func SetNextLineStyle() {
	C.wrap_ImPlot_SetNextLineStyle()
}

func SetNextMarkerStyle() {
	C.wrap_ImPlot_SetNextMarkerStyle()
}

func SetupAxes(x_label, y_label string) {
	x_labelArg, x_labelFin := internal.WrapString[C.char](x_label)
	y_labelArg, y_labelFin := internal.WrapString[C.char](y_label)
	C.wrap_ImPlot_SetupAxes(x_labelArg, y_labelArg)

	x_labelFin()
	y_labelFin()
}

func SetupAxesLimits(x_min, x_max, y_min, y_max float64) {
	C.wrap_ImPlot_SetupAxesLimits(C.double(x_min), C.double(x_max), C.double(y_min), C.double(y_max))
}

func SetupAxis(axis AxisEnum) {
	C.wrap_ImPlot_SetupAxis(C.ImAxis(axis))
}

func SetupAxisFormatPlotFormatter(axis AxisEnum, formatter Formatter) {
	formatterArg, formatterFin := formatter.C()
	C.wrap_ImPlot_SetupAxisFormat_PlotFormatter(C.ImAxis(axis), internal.ReinterpretCast[C.ImPlotFormatter](formatterArg))

	formatterFin()
}

func SetupAxisLimits(axis AxisEnum, v_min, v_max float64) {
	C.wrap_ImPlot_SetupAxisLimits(C.ImAxis(axis), C.double(v_min), C.double(v_max))
}

func SetupAxisScalePlotTransform(axis AxisEnum, forward, inverse Transform) {
	forwardArg, forwardFin := forward.C()
	inverseArg, inverseFin := inverse.C()
	C.wrap_ImPlot_SetupAxisScale_PlotTransform(C.ImAxis(axis), internal.ReinterpretCast[C.ImPlotTransform](forwardArg), internal.ReinterpretCast[C.ImPlotTransform](inverseArg))

	forwardFin()
	inverseFin()
}

func SetupAxisTicksdouble(axis AxisEnum, v_min, v_max float64, n_ticks int32) {
	C.wrap_ImPlot_SetupAxisTicks_double(C.ImAxis(axis), C.double(v_min), C.double(v_max), C.int(n_ticks))
}

func SetupAxisTicksdoublePtr(axis AxisEnum, values *float64, n_ticks int32) {
	valuesArg, valuesFin := internal.WrapNumberPtr[C.double, float64](values)
	C.wrap_ImPlot_SetupAxisTicks_doublePtr(C.ImAxis(axis), valuesArg, C.int(n_ticks))

	valuesFin()
}

func SetupLegend(location Location) {
	C.wrap_ImPlot_SetupLegend(C.ImPlotLocation(location))
}

func SetupMouseText(location Location) {
	C.wrap_ImPlot_SetupMouseText(C.ImPlotLocation(location))
}

func ShowAltLegend(title_id string) {
	title_idArg, title_idFin := internal.WrapString[C.char](title_id)
	C.wrap_ImPlot_ShowAltLegend(title_idArg)

	title_idFin()
}

func ShowAxisContextMenu(axis, equal_axis *Axis) {
	axisArg, axisFin := axis.Handle()
	equal_axisArg, equal_axisFin := equal_axis.Handle()
	C.wrap_ImPlot_ShowAxisContextMenu(internal.ReinterpretCast[*C.ImPlotAxis](axisArg), internal.ReinterpretCast[*C.ImPlotAxis](equal_axisArg))

	axisFin()
	equal_axisFin()
}

func ShowDatePicker(id string, level *int32, t *PlotTime) bool {
	idArg, idFin := internal.WrapString[C.char](id)
	levelArg, levelFin := internal.WrapNumberPtr[C.int, int32](level)
	tArg, tFin := internal.Wrap(t)

	defer func() {
		idFin()
		levelFin()
		tFin()
	}()
	return C.wrap_ImPlot_ShowDatePicker(idArg, levelArg, internal.ReinterpretCast[*C.ImPlotTime](tArg)) == C.bool(true)
}

func ShowDemoWindow() {
	C.wrap_ImPlot_ShowDemoWindow()
}

func ShowMetricsWindow() {
	C.wrap_ImPlot_ShowMetricsWindow()
}

func ShowStyleEditor() {
	C.wrap_ImPlot_ShowStyleEditor()
}

func StyleColorsAuto() {
	C.wrap_ImPlot_StyleColorsAuto()
}

func StyleColorsClassic() {
	C.wrap_ImPlot_StyleColorsClassic()
}

func StyleColorsDark() {
	C.wrap_ImPlot_StyleColorsDark()
}

func StyleColorsLight() {
	C.wrap_ImPlot_StyleColorsLight()
}

func TagXBool(x float64, col imgui.Vec4) {
	C.wrap_ImPlot_TagX_Bool(C.double(x), internal.ReinterpretCast[C.ImVec4](col.ToC()))
}

func TagYBool(y float64, col imgui.Vec4) {
	C.wrap_ImPlot_TagY_Bool(C.double(y), internal.ReinterpretCast[C.ImVec4](col.ToC()))
}

func (self *FormatterTimeData) TimeDataGetTime() PlotTime {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() PlotTime {
		out := C.wrap_Formatter_Time_Data_GetTime(internal.ReinterpretCast[*C.Formatter_Time_Data](selfArg))
		return *(&PlotTime{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *FormatterTimeData) TimeDataGetSpec() DateTimeSpec {
	selfArg, selfFin := self.Handle()

	result := C.wrap_Formatter_Time_Data_GetSpec(internal.ReinterpretCast[*C.Formatter_Time_Data](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewDateTimeSpecFromC(func() *C.ImPlotDateTimeSpec { result := result; return &result }())
}

func (self *FormatterTimeData) TimeDataGetUserFormatter() Formatter {
	selfArg, selfFin := self.Handle()

	result := C.wrap_Formatter_Time_Data_GetUserFormatter(internal.ReinterpretCast[*C.Formatter_Time_Data](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewFormatterFromC(func() *C.ImPlotFormatter { result := result; return &result }())
}

func (self *FormatterTimeData) TimeDataGetUserFormatterData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_Formatter_Time_Data_GetUserFormatterData(internal.ReinterpretCast[*C.Formatter_Time_Data](selfArg)))
}

func (self AlignmentData) SetVertical(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAlignmentData_SetVertical(selfArg, C.bool(v))
}

func (self AlignmentData) SetPadA(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAlignmentData_SetPadA(selfArg, C.float(v))
}

func (self AlignmentData) SetPadB(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAlignmentData_SetPadB(selfArg, C.float(v))
}

func (self AlignmentData) SetPadAMax(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAlignmentData_SetPadAMax(selfArg, C.float(v))
}

func (self AlignmentData) SetPadBMax(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAlignmentData_SetPadBMax(selfArg, C.float(v))
}

func (self *AlignmentData) Vertical() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAlignmentData_GetVertical(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg)) == C.bool(true)
}

func (self *AlignmentData) PadA() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotAlignmentData_GetPadA(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg)))
}

func (self *AlignmentData) PadB() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotAlignmentData_GetPadB(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg)))
}

func (self *AlignmentData) PadAMax() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotAlignmentData_GetPadAMax(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg)))
}

func (self *AlignmentData) PadBMax() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotAlignmentData_GetPadBMax(internal.ReinterpretCast[*C.ImPlotAlignmentData](selfArg)))
}

func (self Annotation) SetPos(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAnnotation_SetPos(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Annotation) SetOffset(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAnnotation_SetOffset(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Annotation) SetColorBg(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAnnotation_SetColorBg(selfArg, C.ImU32(v))
}

func (self Annotation) SetColorFg(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAnnotation_SetColorFg(selfArg, C.ImU32(v))
}

func (self Annotation) SetTextOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAnnotation_SetTextOffset(selfArg, C.int(v))
}

func (self Annotation) SetClamp(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAnnotation_SetClamp(selfArg, C.bool(v))
}

func (self *Annotation) Pos() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotAnnotation_GetPos(internal.ReinterpretCast[*C.ImPlotAnnotation](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Annotation) Offset() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotAnnotation_GetOffset(internal.ReinterpretCast[*C.ImPlotAnnotation](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Annotation) ColorBg() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAnnotation_GetColorBg(internal.ReinterpretCast[*C.ImPlotAnnotation](selfArg)))
}

func (self *Annotation) ColorFg() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAnnotation_GetColorFg(internal.ReinterpretCast[*C.ImPlotAnnotation](selfArg)))
}

func (self *Annotation) TextOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotAnnotation_GetTextOffset(internal.ReinterpretCast[*C.ImPlotAnnotation](selfArg)))
}

func (self *Annotation) Clamp() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAnnotation_GetClamp(internal.ReinterpretCast[*C.ImPlotAnnotation](selfArg)) == C.bool(true)
}

func (self AnnotationCollection) SetAnnotations(v vectors.Vector[Annotation]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImPlotAnnotation)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImPlotAnnotation](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAnnotationCollection_SetAnnotations(selfArg, *vVecArg)
}

func (self AnnotationCollection) SetTextBuffer(v imgui.TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAnnotationCollection_SetTextBuffer(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self AnnotationCollection) SetSize(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAnnotationCollection_SetSize(selfArg, C.int(v))
}

func (self *AnnotationCollection) Annotations() vectors.Vector[Annotation] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotAnnotationCollection_GetAnnotations(internal.ReinterpretCast[*C.ImPlotAnnotationCollection](selfArg)).Size, C.wrap_ImPlotAnnotationCollection_GetAnnotations(internal.ReinterpretCast[*C.ImPlotAnnotationCollection](selfArg)).Capacity, NewAnnotationFromC(C.wrap_ImPlotAnnotationCollection_GetAnnotations(internal.ReinterpretCast[*C.ImPlotAnnotationCollection](selfArg)).Data))
}

func (self *AnnotationCollection) TextBuffer() imgui.TextBuffer {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewTextBufferFromC(func() *C.ImGuiTextBuffer {
		result := C.wrap_ImPlotAnnotationCollection_GetTextBuffer(internal.ReinterpretCast[*C.ImPlotAnnotationCollection](selfArg))
		return &result
	}())
}

func (self *AnnotationCollection) Size() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotAnnotationCollection_GetSize(internal.ReinterpretCast[*C.ImPlotAnnotationCollection](selfArg)))
}

func (self Axis) SetID(v imgui.ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Axis) SetFlags(v AxisFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetFlags(selfArg, C.ImPlotAxisFlags(v))
}

func (self Axis) SetPreviousFlags(v AxisFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetPreviousFlags(selfArg, C.ImPlotAxisFlags(v))
}

func (self Axis) SetRange(v Range) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetRange(selfArg, internal.ReinterpretCast[C.ImPlotRange](vArg))
}

func (self Axis) SetRangeCond(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetRangeCond(selfArg, C.ImPlotCond(v))
}

func (self Axis) SetScale(v Scale) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetScale(selfArg, C.ImPlotScale(v))
}

func (self Axis) SetFitExtents(v Range) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetFitExtents(selfArg, internal.ReinterpretCast[C.ImPlotRange](vArg))
}

func (self Axis) SetOrthoAxis(v *Axis) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetOrthoAxis(selfArg, internal.ReinterpretCast[*C.ImPlotAxis](vArg))
}

func (self Axis) SetConstraintRange(v Range) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetConstraintRange(selfArg, internal.ReinterpretCast[C.ImPlotRange](vArg))
}

func (self Axis) SetConstraintZoom(v Range) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetConstraintZoom(selfArg, internal.ReinterpretCast[C.ImPlotRange](vArg))
}

func (self Axis) SetTicker(v Ticker) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetTicker(selfArg, internal.ReinterpretCast[C.ImPlotTicker](vArg))
}

func (self Axis) SetFormatter(v Formatter) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetFormatter(selfArg, internal.ReinterpretCast[C.ImPlotFormatter](vArg))
}

func (self Axis) SetFormatterData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetFormatterData(selfArg, C.uintptr_t(v))
}

func (self Axis) SetFormatSpec(v *[16]rune) {
	vArg := make([]C.char, len(v))
	for i, vV := range v {
		vArg[i] = C.char(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetFormatSpec(selfArg, (*C.char)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = rune(vV)
	}
}

func (self Axis) SetLinkedMin(v *float64) {
	vArg, _ := internal.WrapNumberPtr[C.double, float64](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetLinkedMin(selfArg, vArg)
}

func (self Axis) SetLinkedMax(v *float64) {
	vArg, _ := internal.WrapNumberPtr[C.double, float64](v)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetLinkedMax(selfArg, vArg)
}

func (self Axis) SetPickerLevel(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetPickerLevel(selfArg, C.int(v))
}

func (self Axis) SetPickerTimeMin(v PlotTime) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetPickerTimeMin(selfArg, internal.ReinterpretCast[C.ImPlotTime](v.ToC()))
}

func (self Axis) SetPickerTimeMax(v PlotTime) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetPickerTimeMax(selfArg, internal.ReinterpretCast[C.ImPlotTime](v.ToC()))
}

func (self Axis) SetTransformForward(v Transform) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetTransformForward(selfArg, internal.ReinterpretCast[C.ImPlotTransform](vArg))
}

func (self Axis) SetTransformInverse(v Transform) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetTransformInverse(selfArg, internal.ReinterpretCast[C.ImPlotTransform](vArg))
}

func (self Axis) SetTransformData(v uintptr) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetTransformData(selfArg, C.uintptr_t(v))
}

func (self Axis) SetPixelMin(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetPixelMin(selfArg, C.float(v))
}

func (self Axis) SetPixelMax(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetPixelMax(selfArg, C.float(v))
}

func (self Axis) SetScaleMin(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetScaleMin(selfArg, C.double(v))
}

func (self Axis) SetScaleMax(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetScaleMax(selfArg, C.double(v))
}

func (self Axis) SetScaleToPixel(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetScaleToPixel(selfArg, C.double(v))
}

func (self Axis) SetDatum1(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetDatum1(selfArg, C.float(v))
}

func (self Axis) SetDatum2(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetDatum2(selfArg, C.float(v))
}

func (self Axis) SetHoverRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetHoverRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Axis) SetLabelOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetLabelOffset(selfArg, C.int(v))
}

func (self Axis) SetColorMaj(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetColorMaj(selfArg, C.ImU32(v))
}

func (self Axis) SetColorMin(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetColorMin(selfArg, C.ImU32(v))
}

func (self Axis) SetColorTick(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetColorTick(selfArg, C.ImU32(v))
}

func (self Axis) SetColorTxt(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetColorTxt(selfArg, C.ImU32(v))
}

func (self Axis) SetColorBg(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetColorBg(selfArg, C.ImU32(v))
}

func (self Axis) SetColorHov(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetColorHov(selfArg, C.ImU32(v))
}

func (self Axis) SetColorAct(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetColorAct(selfArg, C.ImU32(v))
}

func (self Axis) SetColorHiLi(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetColorHiLi(selfArg, C.ImU32(v))
}

func (self Axis) SetEnabled(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetEnabled(selfArg, C.bool(v))
}

func (self Axis) SetVertical(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetVertical(selfArg, C.bool(v))
}

func (self Axis) SetFitThisFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetFitThisFrame(selfArg, C.bool(v))
}

func (self Axis) SetHasRange(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetHasRange(selfArg, C.bool(v))
}

func (self Axis) SetHasFormatSpec(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetHasFormatSpec(selfArg, C.bool(v))
}

func (self Axis) SetShowDefaultTicks(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetShowDefaultTicks(selfArg, C.bool(v))
}

func (self Axis) SetHovered(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetHovered(selfArg, C.bool(v))
}

func (self Axis) SetHeld(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotAxis_SetHeld(selfArg, C.bool(v))
}

func (self *Axis) ID() imgui.ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_ImPlotAxis_GetID(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))
		return &result
	}())
}

func (self *Axis) Flags() AxisFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return AxisFlags(C.wrap_ImPlotAxis_GetFlags(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) PreviousFlags() AxisFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return AxisFlags(C.wrap_ImPlotAxis_GetPreviousFlags(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) Range() Range {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotAxis_GetRange(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewRangeFromC(func() *C.ImPlotRange { result := result; return &result }())
}

func (self *Axis) RangeCond() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImPlotAxis_GetRangeCond(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) Scale() Scale {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Scale(C.wrap_ImPlotAxis_GetScale(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) FitExtents() Range {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotAxis_GetFitExtents(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewRangeFromC(func() *C.ImPlotRange { result := result; return &result }())
}

func (self *Axis) OrthoAxis() *Axis {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewAxisFromC(C.wrap_ImPlotAxis_GetOrthoAxis(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ConstraintRange() Range {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotAxis_GetConstraintRange(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewRangeFromC(func() *C.ImPlotRange { result := result; return &result }())
}

func (self *Axis) ConstraintZoom() Range {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotAxis_GetConstraintZoom(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewRangeFromC(func() *C.ImPlotRange { result := result; return &result }())
}

func (self *Axis) Ticker() Ticker {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotAxis_GetTicker(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTickerFromC(func() *C.ImPlotTicker { result := result; return &result }())
}

func (self *Axis) Formatter() Formatter {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotAxis_GetFormatter(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewFormatterFromC(func() *C.ImPlotFormatter { result := result; return &result }())
}

func (self *Axis) FormatterData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImPlotAxis_GetFormatterData(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) FormatSpec() [16]rune {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [16]rune {
		result := [16]rune{}
		resultMirr := C.wrap_ImPlotAxis_GetFormatSpec(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))
		for i := range result {
			result[i] = rune(C.implot_char_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *Axis) LinkedMin() *float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (*float64)(C.wrap_ImPlotAxis_GetLinkedMin(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) LinkedMax() *float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (*float64)(C.wrap_ImPlotAxis_GetLinkedMax(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) PickerLevel() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotAxis_GetPickerLevel(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) PickerTimeMin() PlotTime {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() PlotTime {
		out := C.wrap_ImPlotAxis_GetPickerTimeMin(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))
		return *(&PlotTime{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Axis) PickerTimeMax() PlotTime {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() PlotTime {
		out := C.wrap_ImPlotAxis_GetPickerTimeMax(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))
		return *(&PlotTime{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Axis) TransformForward() Transform {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotAxis_GetTransformForward(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTransformFromC(func() *C.ImPlotTransform { result := result; return &result }())
}

func (self *Axis) TransformInverse() Transform {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotAxis_GetTransformInverse(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTransformFromC(func() *C.ImPlotTransform { result := result; return &result }())
}

func (self *Axis) TransformData() uintptr {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return uintptr(C.wrap_ImPlotAxis_GetTransformData(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) PixelMin() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotAxis_GetPixelMin(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) PixelMax() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotAxis_GetPixelMax(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ScaleMin() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotAxis_GetScaleMin(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ScaleMax() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotAxis_GetScaleMax(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ScaleToPixel() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotAxis_GetScaleToPixel(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) Datum1() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotAxis_GetDatum1(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) Datum2() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotAxis_GetDatum2(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) HoverRect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotAxis_GetHoverRect(internal.ReinterpretCast[*C.ImPlotAxis](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Axis) LabelOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotAxis_GetLabelOffset(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ColorMaj() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAxis_GetColorMaj(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ColorMin() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAxis_GetColorMin(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ColorTick() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAxis_GetColorTick(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ColorTxt() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAxis_GetColorTxt(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ColorBg() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAxis_GetColorBg(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ColorHov() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAxis_GetColorHov(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ColorAct() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAxis_GetColorAct(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) ColorHiLi() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotAxis_GetColorHiLi(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)))
}

func (self *Axis) Enabled() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_GetEnabled(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) Vertical() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_GetVertical(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) FitThisFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_GetFitThisFrame(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) HasRange() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_GetHasRange(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) HasFormatSpec() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_GetHasFormatSpec(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) ShowDefaultTicks() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_GetShowDefaultTicks(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) Hovered() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_GetHovered(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self *Axis) Held() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotAxis_GetHeld(internal.ReinterpretCast[*C.ImPlotAxis](selfArg)) == C.bool(true)
}

func (self ColormapData) SetKeys(v vectors.Vector[uint32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.ImU32, uint32](vData)
	vVecArg := new(C.ImVector_ImU32)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetKeys(selfArg, *vVecArg)
}

func (self ColormapData) SetKeyCounts(v vectors.Vector[int32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.int, int32](vData)
	vVecArg := new(C.ImVector_int)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetKeyCounts(selfArg, *vVecArg)
}

func (self ColormapData) SetKeyOffsets(v vectors.Vector[int32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.int, int32](vData)
	vVecArg := new(C.ImVector_int)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetKeyOffsets(selfArg, *vVecArg)
}

func (self ColormapData) SetTables(v vectors.Vector[uint32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.ImU32, uint32](vData)
	vVecArg := new(C.ImVector_ImU32)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetTables(selfArg, *vVecArg)
}

func (self ColormapData) SetTableSizes(v vectors.Vector[int32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.int, int32](vData)
	vVecArg := new(C.ImVector_int)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetTableSizes(selfArg, *vVecArg)
}

func (self ColormapData) SetTableOffsets(v vectors.Vector[int32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.int, int32](vData)
	vVecArg := new(C.ImVector_int)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetTableOffsets(selfArg, *vVecArg)
}

func (self ColormapData) SetText(v imgui.TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetText(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self ColormapData) SetTextOffsets(v vectors.Vector[int32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.int, int32](vData)
	vVecArg := new(C.ImVector_int)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetTextOffsets(selfArg, *vVecArg)
}

func (self ColormapData) SetQuals(v vectors.Vector[bool]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.bool, bool](vData)
	vVecArg := new(C.ImVector_bool)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetQuals(selfArg, *vVecArg)
}

func (self ColormapData) SetMap(v imgui.Storage) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetMap(selfArg, internal.ReinterpretCast[C.ImGuiStorage](vArg))
}

func (self ColormapData) SetCount(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotColormapData_SetCount(selfArg, C.int(v))
}

func (self *ColormapData) KeyCounts() vectors.Vector[int32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotColormapData_GetKeyCounts(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Size, C.wrap_ImPlotColormapData_GetKeyCounts(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Capacity, (*int32)(C.wrap_ImPlotColormapData_GetKeyCounts(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Data))
}

func (self *ColormapData) KeyOffsets() vectors.Vector[int32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotColormapData_GetKeyOffsets(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Size, C.wrap_ImPlotColormapData_GetKeyOffsets(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Capacity, (*int32)(C.wrap_ImPlotColormapData_GetKeyOffsets(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Data))
}

func (self *ColormapData) Tables() vectors.Vector[uint32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotColormapData_GetTables(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Size, C.wrap_ImPlotColormapData_GetTables(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Capacity, (*uint32)(C.wrap_ImPlotColormapData_GetTables(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Data))
}

func (self *ColormapData) TableSizes() vectors.Vector[int32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotColormapData_GetTableSizes(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Size, C.wrap_ImPlotColormapData_GetTableSizes(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Capacity, (*int32)(C.wrap_ImPlotColormapData_GetTableSizes(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Data))
}

func (self *ColormapData) TableOffsets() vectors.Vector[int32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotColormapData_GetTableOffsets(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Size, C.wrap_ImPlotColormapData_GetTableOffsets(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Capacity, (*int32)(C.wrap_ImPlotColormapData_GetTableOffsets(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Data))
}

func (self *ColormapData) Text() imgui.TextBuffer {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewTextBufferFromC(func() *C.ImGuiTextBuffer {
		result := C.wrap_ImPlotColormapData_GetText(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg))
		return &result
	}())
}

func (self *ColormapData) TextOffsets() vectors.Vector[int32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotColormapData_GetTextOffsets(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Size, C.wrap_ImPlotColormapData_GetTextOffsets(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Capacity, (*int32)(C.wrap_ImPlotColormapData_GetTextOffsets(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Data))
}

func (self *ColormapData) Quals() vectors.Vector[bool] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotColormapData_GetQuals(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Size, C.wrap_ImPlotColormapData_GetQuals(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Capacity, (*bool)(C.wrap_ImPlotColormapData_GetQuals(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)).Data))
}

func (self *ColormapData) Map() imgui.Storage {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewStorageFromC(func() *C.ImGuiStorage {
		result := C.wrap_ImPlotColormapData_GetMap(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg))
		return &result
	}())
}

func (self *ColormapData) Count() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotColormapData_GetCount(internal.ReinterpretCast[*C.ImPlotColormapData](selfArg)))
}

func (self Context) SetCurrentPlot(v *Plot) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetCurrentPlot(selfArg, internal.ReinterpretCast[*C.ImPlotPlot](vArg))
}

func (self Context) SetCurrentSubplot(v *Subplot) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetCurrentSubplot(selfArg, internal.ReinterpretCast[*C.ImPlotSubplot](vArg))
}

func (self Context) SetCurrentItems(v *ItemGroup) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetCurrentItems(selfArg, internal.ReinterpretCast[*C.ImPlotItemGroup](vArg))
}

func (self Context) SetCurrentItem(v *Item) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetCurrentItem(selfArg, internal.ReinterpretCast[*C.ImPlotItem](vArg))
}

func (self Context) SetPreviousItem(v *Item) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetPreviousItem(selfArg, internal.ReinterpretCast[*C.ImPlotItem](vArg))
}

func (self Context) SetCTicker(v Ticker) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetCTicker(selfArg, internal.ReinterpretCast[C.ImPlotTicker](vArg))
}

func (self Context) SetAnnotations(v AnnotationCollection) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetAnnotations(selfArg, internal.ReinterpretCast[C.ImPlotAnnotationCollection](vArg))
}

func (self Context) SetTags(v TagCollection) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetTags(selfArg, internal.ReinterpretCast[C.ImPlotTagCollection](vArg))
}

func (self Context) SetStyle(v Style) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetStyle(selfArg, internal.ReinterpretCast[C.ImPlotStyle](vArg))
}

func (self Context) SetColorModifiers(v vectors.Vector[imgui.ColorMod]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiColorMod)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiColorMod](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetColorModifiers(selfArg, *vVecArg)
}

func (self Context) SetStyleModifiers(v vectors.Vector[imgui.StyleMod]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImGuiStyleMod)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImGuiStyleMod](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetStyleModifiers(selfArg, *vVecArg)
}

func (self Context) SetColormapData(v ColormapData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetColormapData(selfArg, internal.ReinterpretCast[C.ImPlotColormapData](vArg))
}

func (self Context) SetColormapModifiers(v vectors.Vector[Colormap]) {
	vData := v.Data

	vVecArg := new(C.ImVector_ImPlotColormap)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = (*C.ImPlotColormap)(vData)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetColormapModifiers(selfArg, *vVecArg)
}

func (self Context) SetTm(v Tm) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetTm(selfArg, internal.ReinterpretCast[C.struct_tm](v.ToC()))
}

func (self Context) SetTempDouble1(v vectors.Vector[float64]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.double, float64](vData)
	vVecArg := new(C.ImVector_double)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetTempDouble1(selfArg, *vVecArg)
}

func (self Context) SetTempDouble2(v vectors.Vector[float64]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.double, float64](vData)
	vVecArg := new(C.ImVector_double)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetTempDouble2(selfArg, *vVecArg)
}

func (self Context) SetTempInt1(v vectors.Vector[int32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.int, int32](vData)
	vVecArg := new(C.ImVector_int)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetTempInt1(selfArg, *vVecArg)
}

func (self Context) SetDigitalPlotItemCnt(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetDigitalPlotItemCnt(selfArg, C.int(v))
}

func (self Context) SetDigitalPlotOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetDigitalPlotOffset(selfArg, C.int(v))
}

func (self Context) SetNextPlotData(v NextPlotData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetNextPlotData(selfArg, internal.ReinterpretCast[C.ImPlotNextPlotData](vArg))
}

func (self Context) SetNextItemData(v NextItemData) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetNextItemData(selfArg, internal.ReinterpretCast[C.ImPlotNextItemData](vArg))
}

func (self Context) SetInputMap(v InputMap) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetInputMap(selfArg, internal.ReinterpretCast[C.ImPlotInputMap](vArg))
}

func (self Context) SetOpenContextThisFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetOpenContextThisFrame(selfArg, C.bool(v))
}

func (self Context) SetMousePosStringBuilder(v imgui.TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetMousePosStringBuilder(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self Context) SetSortItems(v *ItemGroup) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetSortItems(selfArg, internal.ReinterpretCast[*C.ImPlotItemGroup](vArg))
}

func (self Context) SetCurrentAlignmentH(v *AlignmentData) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetCurrentAlignmentH(selfArg, internal.ReinterpretCast[*C.ImPlotAlignmentData](vArg))
}

func (self Context) SetCurrentAlignmentV(v *AlignmentData) {
	vArg, _ := v.Handle()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotContext_SetCurrentAlignmentV(selfArg, internal.ReinterpretCast[*C.ImPlotAlignmentData](vArg))
}

func (self *Context) CurrentPlot() *Plot {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewPlotFromC(C.wrap_ImPlotContext_GetCurrentPlot(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self *Context) CurrentSubplot() *Subplot {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewSubplotFromC(C.wrap_ImPlotContext_GetCurrentSubplot(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self *Context) CurrentItems() *ItemGroup {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewItemGroupFromC(C.wrap_ImPlotContext_GetCurrentItems(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self *Context) CurrentItem() *Item {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewItemFromC(C.wrap_ImPlotContext_GetCurrentItem(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self *Context) PreviousItem() *Item {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewItemFromC(C.wrap_ImPlotContext_GetPreviousItem(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self *Context) CTicker() Ticker {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotContext_GetCTicker(internal.ReinterpretCast[*C.ImPlotContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTickerFromC(func() *C.ImPlotTicker { result := result; return &result }())
}

func (self *Context) Annotations() AnnotationCollection {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotContext_GetAnnotations(internal.ReinterpretCast[*C.ImPlotContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewAnnotationCollectionFromC(func() *C.ImPlotAnnotationCollection { result := result; return &result }())
}

func (self *Context) Tags() TagCollection {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotContext_GetTags(internal.ReinterpretCast[*C.ImPlotContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewTagCollectionFromC(func() *C.ImPlotTagCollection { result := result; return &result }())
}

func (self *Context) Style() Style {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotContext_GetStyle(internal.ReinterpretCast[*C.ImPlotContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewStyleFromC(func() *C.ImPlotStyle { result := result; return &result }())
}

func (self *Context) ColorModifiers() vectors.Vector[imgui.ColorMod] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotContext_GetColorModifiers(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Size, C.wrap_ImPlotContext_GetColorModifiers(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Capacity, imgui.NewColorModFromC(C.wrap_ImPlotContext_GetColorModifiers(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Data))
}

func (self *Context) StyleModifiers() vectors.Vector[imgui.StyleMod] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotContext_GetStyleModifiers(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Size, C.wrap_ImPlotContext_GetStyleModifiers(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Capacity, imgui.NewStyleModFromC(C.wrap_ImPlotContext_GetStyleModifiers(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Data))
}

func (self *Context) ColormapData() ColormapData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotContext_GetColormapData(internal.ReinterpretCast[*C.ImPlotContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewColormapDataFromC(func() *C.ImPlotColormapData { result := result; return &result }())
}

func (self *Context) ColormapModifiers() vectors.Vector[Colormap] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotContext_GetColormapModifiers(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Size, C.wrap_ImPlotContext_GetColormapModifiers(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Capacity, (*Colormap)(C.wrap_ImPlotContext_GetColormapModifiers(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Data))
}

func (self *Context) Tm() Tm {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() Tm {
		out := C.wrap_ImPlotContext_GetTm(internal.ReinterpretCast[*C.ImPlotContext](selfArg))
		return *(&Tm{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Context) TempDouble1() vectors.Vector[float64] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotContext_GetTempDouble1(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Size, C.wrap_ImPlotContext_GetTempDouble1(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Capacity, (*float64)(C.wrap_ImPlotContext_GetTempDouble1(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Data))
}

func (self *Context) TempDouble2() vectors.Vector[float64] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotContext_GetTempDouble2(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Size, C.wrap_ImPlotContext_GetTempDouble2(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Capacity, (*float64)(C.wrap_ImPlotContext_GetTempDouble2(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Data))
}

func (self *Context) TempInt1() vectors.Vector[int32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotContext_GetTempInt1(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Size, C.wrap_ImPlotContext_GetTempInt1(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Capacity, (*int32)(C.wrap_ImPlotContext_GetTempInt1(internal.ReinterpretCast[*C.ImPlotContext](selfArg)).Data))
}

func (self *Context) DigitalPlotItemCnt() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotContext_GetDigitalPlotItemCnt(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self *Context) DigitalPlotOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotContext_GetDigitalPlotOffset(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self *Context) NextPlotData() NextPlotData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotContext_GetNextPlotData(internal.ReinterpretCast[*C.ImPlotContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewNextPlotDataFromC(func() *C.ImPlotNextPlotData { result := result; return &result }())
}

func (self *Context) NextItemData() NextItemData {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotContext_GetNextItemData(internal.ReinterpretCast[*C.ImPlotContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewNextItemDataFromC(func() *C.ImPlotNextItemData { result := result; return &result }())
}

func (self *Context) InputMap() InputMap {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotContext_GetInputMap(internal.ReinterpretCast[*C.ImPlotContext](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewInputMapFromC(func() *C.ImPlotInputMap { result := result; return &result }())
}

func (self *Context) OpenContextThisFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotContext_GetOpenContextThisFrame(internal.ReinterpretCast[*C.ImPlotContext](selfArg)) == C.bool(true)
}

func (self *Context) MousePosStringBuilder() imgui.TextBuffer {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewTextBufferFromC(func() *C.ImGuiTextBuffer {
		result := C.wrap_ImPlotContext_GetMousePosStringBuilder(internal.ReinterpretCast[*C.ImPlotContext](selfArg))
		return &result
	}())
}

func (self *Context) SortItems() *ItemGroup {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewItemGroupFromC(C.wrap_ImPlotContext_GetSortItems(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self *Context) CurrentAlignmentH() *AlignmentData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewAlignmentDataFromC(C.wrap_ImPlotContext_GetCurrentAlignmentH(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self *Context) CurrentAlignmentV() *AlignmentData {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return NewAlignmentDataFromC(C.wrap_ImPlotContext_GetCurrentAlignmentV(internal.ReinterpretCast[*C.ImPlotContext](selfArg)))
}

func (self DateTimeSpec) SetDate(v DateFmt) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotDateTimeSpec_SetDate(selfArg, C.ImPlotDateFmt(v))
}

func (self DateTimeSpec) SetTime(v TimeFmt) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotDateTimeSpec_SetTime(selfArg, C.ImPlotTimeFmt(v))
}

func (self DateTimeSpec) SetUseISO8601(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotDateTimeSpec_SetUseISO8601(selfArg, C.bool(v))
}

func (self DateTimeSpec) SetUse24HourClock(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotDateTimeSpec_SetUse24HourClock(selfArg, C.bool(v))
}

func (self *DateTimeSpec) Date() DateFmt {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return DateFmt(C.wrap_ImPlotDateTimeSpec_GetDate(internal.ReinterpretCast[*C.ImPlotDateTimeSpec](selfArg)))
}

func (self *DateTimeSpec) Time() TimeFmt {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return TimeFmt(C.wrap_ImPlotDateTimeSpec_GetTime(internal.ReinterpretCast[*C.ImPlotDateTimeSpec](selfArg)))
}

func (self *DateTimeSpec) UseISO8601() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotDateTimeSpec_GetUseISO8601(internal.ReinterpretCast[*C.ImPlotDateTimeSpec](selfArg)) == C.bool(true)
}

func (self *DateTimeSpec) Use24HourClock() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotDateTimeSpec_GetUse24HourClock(internal.ReinterpretCast[*C.ImPlotDateTimeSpec](selfArg)) == C.bool(true)
}

func (self InputMap) SetPan(v imgui.MouseButton) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetPan(selfArg, C.ImGuiMouseButton(v))
}

func (self InputMap) SetPanMod(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetPanMod(selfArg, C.int(v))
}

func (self InputMap) SetFit(v imgui.MouseButton) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetFit(selfArg, C.ImGuiMouseButton(v))
}

func (self InputMap) SetSelect(v imgui.MouseButton) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetSelect(selfArg, C.ImGuiMouseButton(v))
}

func (self InputMap) SetSelectCancel(v imgui.MouseButton) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetSelectCancel(selfArg, C.ImGuiMouseButton(v))
}

func (self InputMap) SetSelectMod(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetSelectMod(selfArg, C.int(v))
}

func (self InputMap) SetSelectHorzMod(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetSelectHorzMod(selfArg, C.int(v))
}

func (self InputMap) SetSelectVertMod(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetSelectVertMod(selfArg, C.int(v))
}

func (self InputMap) SetMenu(v imgui.MouseButton) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetMenu(selfArg, C.ImGuiMouseButton(v))
}

func (self InputMap) SetOverrideMod(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetOverrideMod(selfArg, C.int(v))
}

func (self InputMap) SetZoomMod(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetZoomMod(selfArg, C.int(v))
}

func (self InputMap) SetZoomRate(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotInputMap_SetZoomRate(selfArg, C.float(v))
}

func (self *InputMap) Pan() imgui.MouseButton {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return imgui.MouseButton(C.wrap_ImPlotInputMap_GetPan(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) PanMod() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotInputMap_GetPanMod(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) Fit() imgui.MouseButton {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return imgui.MouseButton(C.wrap_ImPlotInputMap_GetFit(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) Select() imgui.MouseButton {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return imgui.MouseButton(C.wrap_ImPlotInputMap_GetSelect(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) SelectCancel() imgui.MouseButton {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return imgui.MouseButton(C.wrap_ImPlotInputMap_GetSelectCancel(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) SelectMod() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotInputMap_GetSelectMod(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) SelectHorzMod() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotInputMap_GetSelectHorzMod(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) SelectVertMod() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotInputMap_GetSelectVertMod(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) Menu() imgui.MouseButton {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return imgui.MouseButton(C.wrap_ImPlotInputMap_GetMenu(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) OverrideMod() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotInputMap_GetOverrideMod(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) ZoomMod() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotInputMap_GetZoomMod(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self *InputMap) ZoomRate() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotInputMap_GetZoomRate(internal.ReinterpretCast[*C.ImPlotInputMap](selfArg)))
}

func (self Item) SetID(v imgui.ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItem_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Item) SetColor(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItem_SetColor(selfArg, C.ImU32(v))
}

func (self Item) SetLegendHoverRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItem_SetLegendHoverRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Item) SetNameOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItem_SetNameOffset(selfArg, C.int(v))
}

func (self Item) SetShow(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItem_SetShow(selfArg, C.bool(v))
}

func (self Item) SetLegendHovered(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItem_SetLegendHovered(selfArg, C.bool(v))
}

func (self Item) SetSeenThisFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItem_SetSeenThisFrame(selfArg, C.bool(v))
}

func (self *Item) ID() imgui.ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_ImPlotItem_GetID(internal.ReinterpretCast[*C.ImPlotItem](selfArg))
		return &result
	}())
}

func (self *Item) Color() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotItem_GetColor(internal.ReinterpretCast[*C.ImPlotItem](selfArg)))
}

func (self *Item) LegendHoverRect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotItem_GetLegendHoverRect(internal.ReinterpretCast[*C.ImPlotItem](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Item) NameOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotItem_GetNameOffset(internal.ReinterpretCast[*C.ImPlotItem](selfArg)))
}

func (self *Item) Show() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotItem_GetShow(internal.ReinterpretCast[*C.ImPlotItem](selfArg)) == C.bool(true)
}

func (self *Item) LegendHovered() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotItem_GetLegendHovered(internal.ReinterpretCast[*C.ImPlotItem](selfArg)) == C.bool(true)
}

func (self *Item) SeenThisFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotItem_GetSeenThisFrame(internal.ReinterpretCast[*C.ImPlotItem](selfArg)) == C.bool(true)
}

func (self ItemGroup) SetID(v imgui.ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItemGroup_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self ItemGroup) SetLegend(v Legend) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItemGroup_SetLegend(selfArg, internal.ReinterpretCast[C.ImPlotLegend](vArg))
}

func (self ItemGroup) SetColormapIdx(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotItemGroup_SetColormapIdx(selfArg, C.int(v))
}

func (self *ItemGroup) ID() imgui.ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_ImPlotItemGroup_GetID(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg))
		return &result
	}())
}

func (self *ItemGroup) Legend() Legend {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotItemGroup_GetLegend(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewLegendFromC(func() *C.ImPlotLegend { result := result; return &result }())
}

func (self *ItemGroup) ColormapIdx() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotItemGroup_GetColormapIdx(internal.ReinterpretCast[*C.ImPlotItemGroup](selfArg)))
}

func (self Legend) SetFlags(v LegendFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetFlags(selfArg, C.ImPlotLegendFlags(v))
}

func (self Legend) SetPreviousFlags(v LegendFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetPreviousFlags(selfArg, C.ImPlotLegendFlags(v))
}

func (self Legend) SetLocation(v Location) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetLocation(selfArg, C.ImPlotLocation(v))
}

func (self Legend) SetPreviousLocation(v Location) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetPreviousLocation(selfArg, C.ImPlotLocation(v))
}

func (self Legend) SetScroll(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetScroll(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Legend) SetIndices(v vectors.Vector[int32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.int, int32](vData)
	vVecArg := new(C.ImVector_int)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetIndices(selfArg, *vVecArg)
}

func (self Legend) SetLabels(v imgui.TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetLabels(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self Legend) SetRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Legend) SetRectClamped(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetRectClamped(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Legend) SetHovered(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetHovered(selfArg, C.bool(v))
}

func (self Legend) SetHeld(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetHeld(selfArg, C.bool(v))
}

func (self Legend) SetCanGoInside(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotLegend_SetCanGoInside(selfArg, C.bool(v))
}

func (self *Legend) Flags() LegendFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return LegendFlags(C.wrap_ImPlotLegend_GetFlags(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)))
}

func (self *Legend) PreviousFlags() LegendFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return LegendFlags(C.wrap_ImPlotLegend_GetPreviousFlags(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)))
}

func (self *Legend) Location() Location {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Location(C.wrap_ImPlotLegend_GetLocation(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)))
}

func (self *Legend) PreviousLocation() Location {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Location(C.wrap_ImPlotLegend_GetPreviousLocation(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)))
}

func (self *Legend) Scroll() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotLegend_GetScroll(internal.ReinterpretCast[*C.ImPlotLegend](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Legend) Indices() vectors.Vector[int32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotLegend_GetIndices(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)).Size, C.wrap_ImPlotLegend_GetIndices(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)).Capacity, (*int32)(C.wrap_ImPlotLegend_GetIndices(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)).Data))
}

func (self *Legend) Labels() imgui.TextBuffer {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewTextBufferFromC(func() *C.ImGuiTextBuffer {
		result := C.wrap_ImPlotLegend_GetLabels(internal.ReinterpretCast[*C.ImPlotLegend](selfArg))
		return &result
	}())
}

func (self *Legend) Rect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotLegend_GetRect(internal.ReinterpretCast[*C.ImPlotLegend](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Legend) RectClamped() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotLegend_GetRectClamped(internal.ReinterpretCast[*C.ImPlotLegend](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Legend) Hovered() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotLegend_GetHovered(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)) == C.bool(true)
}

func (self *Legend) Held() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotLegend_GetHeld(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)) == C.bool(true)
}

func (self *Legend) CanGoInside() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotLegend_GetCanGoInside(internal.ReinterpretCast[*C.ImPlotLegend](selfArg)) == C.bool(true)
}

func (self NextItemData) SetColors(v *[5]imgui.Vec4) {
	vArg := make([]C.ImVec4, len(v))
	for i, vV := range v {
		vArg[i] = internal.ReinterpretCast[C.ImVec4](vV.ToC())
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetColors(selfArg, (*C.ImVec4)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = func() imgui.Vec4 { out := vV; return *(&imgui.Vec4{}).FromC(unsafe.Pointer(&out)) }()
	}
}

func (self NextItemData) SetLineWeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetLineWeight(selfArg, C.float(v))
}

func (self NextItemData) SetMarker(v Marker) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetMarker(selfArg, C.ImPlotMarker(v))
}

func (self NextItemData) SetMarkerSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetMarkerSize(selfArg, C.float(v))
}

func (self NextItemData) SetMarkerWeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetMarkerWeight(selfArg, C.float(v))
}

func (self NextItemData) SetFillAlpha(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetFillAlpha(selfArg, C.float(v))
}

func (self NextItemData) SetErrorBarSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetErrorBarSize(selfArg, C.float(v))
}

func (self NextItemData) SetErrorBarWeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetErrorBarWeight(selfArg, C.float(v))
}

func (self NextItemData) SetDigitalBitHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetDigitalBitHeight(selfArg, C.float(v))
}

func (self NextItemData) SetDigitalBitGap(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetDigitalBitGap(selfArg, C.float(v))
}

func (self NextItemData) SetRenderLine(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetRenderLine(selfArg, C.bool(v))
}

func (self NextItemData) SetRenderFill(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetRenderFill(selfArg, C.bool(v))
}

func (self NextItemData) SetRenderMarkerLine(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetRenderMarkerLine(selfArg, C.bool(v))
}

func (self NextItemData) SetRenderMarkerFill(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetRenderMarkerFill(selfArg, C.bool(v))
}

func (self NextItemData) SetHasHidden(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetHasHidden(selfArg, C.bool(v))
}

func (self NextItemData) SetHidden(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetHidden(selfArg, C.bool(v))
}

func (self NextItemData) SetHiddenCond(v Cond) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextItemData_SetHiddenCond(selfArg, C.ImPlotCond(v))
}

func (self *NextItemData) Colors() [5]imgui.Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [5]imgui.Vec4 {
		result := [5]imgui.Vec4{}
		resultMirr := C.wrap_ImPlotNextItemData_GetColors(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg))
		for i := range result {
			result[i] = func() imgui.Vec4 {
				out := C.implot_ImVec4_GetAtIdx(resultMirr, C.int(i))
				return *(&imgui.Vec4{}).FromC(unsafe.Pointer(&out))
			}()
		}

		return result
	}()
}

func (self *NextItemData) LineWeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotNextItemData_GetLineWeight(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self *NextItemData) Marker() Marker {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Marker(C.wrap_ImPlotNextItemData_GetMarker(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self *NextItemData) MarkerSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotNextItemData_GetMarkerSize(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self *NextItemData) MarkerWeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotNextItemData_GetMarkerWeight(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self *NextItemData) FillAlpha() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotNextItemData_GetFillAlpha(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self *NextItemData) ErrorBarSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotNextItemData_GetErrorBarSize(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self *NextItemData) ErrorBarWeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotNextItemData_GetErrorBarWeight(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self *NextItemData) DigitalBitHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotNextItemData_GetDigitalBitHeight(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self *NextItemData) DigitalBitGap() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotNextItemData_GetDigitalBitGap(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self *NextItemData) RenderLine() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotNextItemData_GetRenderLine(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)) == C.bool(true)
}

func (self *NextItemData) RenderFill() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotNextItemData_GetRenderFill(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)) == C.bool(true)
}

func (self *NextItemData) RenderMarkerLine() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotNextItemData_GetRenderMarkerLine(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)) == C.bool(true)
}

func (self *NextItemData) RenderMarkerFill() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotNextItemData_GetRenderMarkerFill(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)) == C.bool(true)
}

func (self *NextItemData) HasHidden() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotNextItemData_GetHasHidden(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)) == C.bool(true)
}

func (self *NextItemData) Hidden() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotNextItemData_GetHidden(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)) == C.bool(true)
}

func (self *NextItemData) HiddenCond() Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Cond(C.wrap_ImPlotNextItemData_GetHiddenCond(internal.ReinterpretCast[*C.ImPlotNextItemData](selfArg)))
}

func (self NextPlotData) SetRangeCond(v *[6]Cond) {
	vArg := make([]C.ImPlotCond, len(v))
	for i, vV := range v {
		vArg[i] = C.ImPlotCond(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextPlotData_SetRangeCond(selfArg, (*C.ImPlotCond)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = Cond(vV)
	}
}

func (self NextPlotData) SetRange(v *[6]Range) {
	vArg := make([]C.ImPlotRange, len(v))
	for i, vV := range v {
		vVArg, _ := vV.C()
		vArg[i] = internal.ReinterpretCast[C.ImPlotRange](vVArg)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextPlotData_SetRange(selfArg, (*C.ImPlotRange)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = *NewRangeFromC(func() *C.ImPlotRange { result := vV; return &result }())
	}
}

func (self NextPlotData) SetHasRange(v *[6]bool) {
	vArg := make([]C.bool, len(v))
	for i, vV := range v {
		vArg[i] = C.bool(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextPlotData_SetHasRange(selfArg, (*C.bool)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = vV == C.bool(true)
	}
}

func (self NextPlotData) SetFit(v *[6]bool) {
	vArg := make([]C.bool, len(v))
	for i, vV := range v {
		vArg[i] = C.bool(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextPlotData_SetFit(selfArg, (*C.bool)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = vV == C.bool(true)
	}
}

func (self NextPlotData) SetLinkedMin(v *[6]*float64) {
	vArg := make([]*C.double, len(v))
	for i, vV := range v {
		vVArg, _ := internal.WrapNumberPtr[C.double, float64](vV)
		vArg[i] = vVArg
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextPlotData_SetLinkedMin(selfArg, (**C.double)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (*float64)(vV)
	}
}

func (self NextPlotData) SetLinkedMax(v *[6]*float64) {
	vArg := make([]*C.double, len(v))
	for i, vV := range v {
		vVArg, _ := internal.WrapNumberPtr[C.double, float64](vV)
		vArg[i] = vVArg
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotNextPlotData_SetLinkedMax(selfArg, (**C.double)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = (*float64)(vV)
	}
}

func (self *NextPlotData) RangeCond() [6]Cond {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [6]Cond {
		result := [6]Cond{}
		resultMirr := C.wrap_ImPlotNextPlotData_GetRangeCond(internal.ReinterpretCast[*C.ImPlotNextPlotData](selfArg))
		for i := range result {
			result[i] = Cond(C.implot_ImPlotCond_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *NextPlotData) Range() [6]Range {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [6]Range {
		result := [6]Range{}
		resultMirr := C.wrap_ImPlotNextPlotData_GetRange(internal.ReinterpretCast[*C.ImPlotNextPlotData](selfArg))
		for i := range result {
			result[i] = *NewRangeFromC(func() *C.ImPlotRange { result := C.implot_ImPlotRange_GetAtIdx(resultMirr, C.int(i)); return &result }())
		}

		return result
	}()
}

func (self *NextPlotData) HasRange() [6]bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [6]bool {
		result := [6]bool{}
		resultMirr := C.wrap_ImPlotNextPlotData_GetHasRange(internal.ReinterpretCast[*C.ImPlotNextPlotData](selfArg))
		for i := range result {
			result[i] = C.implot_bool_GetAtIdx(resultMirr, C.int(i)) == C.bool(true)
		}

		return result
	}()
}

func (self *NextPlotData) Fit() [6]bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [6]bool {
		result := [6]bool{}
		resultMirr := C.wrap_ImPlotNextPlotData_GetFit(internal.ReinterpretCast[*C.ImPlotNextPlotData](selfArg))
		for i := range result {
			result[i] = C.implot_bool_GetAtIdx(resultMirr, C.int(i)) == C.bool(true)
		}

		return result
	}()
}

func (self *NextPlotData) LinkedMin() [6]*float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [6]*float64 {
		result := [6]*float64{}
		resultMirr := C.wrap_ImPlotNextPlotData_GetLinkedMin(internal.ReinterpretCast[*C.ImPlotNextPlotData](selfArg))
		for i := range result {
			result[i] = (*float64)(C.implot_doublePtr_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *NextPlotData) LinkedMax() [6]*float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [6]*float64 {
		result := [6]*float64{}
		resultMirr := C.wrap_ImPlotNextPlotData_GetLinkedMax(internal.ReinterpretCast[*C.ImPlotNextPlotData](selfArg))
		for i := range result {
			result[i] = (*float64)(C.implot_doublePtr_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self Plot) SetID(v imgui.ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Plot) SetFlags(v Flags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetFlags(selfArg, C.ImPlotFlags(v))
}

func (self Plot) SetPreviousFlags(v Flags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetPreviousFlags(selfArg, C.ImPlotFlags(v))
}

func (self Plot) SetMouseTextLocation(v Location) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetMouseTextLocation(selfArg, C.ImPlotLocation(v))
}

func (self Plot) SetMouseTextFlags(v MouseTextFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetMouseTextFlags(selfArg, C.ImPlotMouseTextFlags(v))
}

func (self Plot) SetAxes(v *[6]Axis) {
	vArg := make([]C.ImPlotAxis, len(v))
	for i, vV := range v {
		vVArg, _ := vV.C()
		vArg[i] = internal.ReinterpretCast[C.ImPlotAxis](vVArg)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetAxes(selfArg, (*C.ImPlotAxis)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = *NewAxisFromC(func() *C.ImPlotAxis { result := vV; return &result }())
	}
}

func (self Plot) SetTextBuffer(v imgui.TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetTextBuffer(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self Plot) SetItems(v ItemGroup) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetItems(selfArg, internal.ReinterpretCast[C.ImPlotItemGroup](vArg))
}

func (self Plot) SetCurrentX(v AxisEnum) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetCurrentX(selfArg, C.ImAxis(v))
}

func (self Plot) SetCurrentY(v AxisEnum) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetCurrentY(selfArg, C.ImAxis(v))
}

func (self Plot) SetFrameRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetFrameRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Plot) SetCanvasRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetCanvasRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Plot) SetPlotRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetPlotRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Plot) SetAxesRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetAxesRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Plot) SetSelectRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetSelectRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Plot) SetSelectStart(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetSelectStart(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Plot) SetTitleOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetTitleOffset(selfArg, C.int(v))
}

func (self Plot) SetJustCreated(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetJustCreated(selfArg, C.bool(v))
}

func (self Plot) SetInitialized(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetInitialized(selfArg, C.bool(v))
}

func (self Plot) SetSetupLocked(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetSetupLocked(selfArg, C.bool(v))
}

func (self Plot) SetFitThisFrame(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetFitThisFrame(selfArg, C.bool(v))
}

func (self Plot) SetHovered(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetHovered(selfArg, C.bool(v))
}

func (self Plot) SetHeld(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetHeld(selfArg, C.bool(v))
}

func (self Plot) SetSelecting(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetSelecting(selfArg, C.bool(v))
}

func (self Plot) SetSelected(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetSelected(selfArg, C.bool(v))
}

func (self Plot) SetContextLocked(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPlot_SetContextLocked(selfArg, C.bool(v))
}

func (self *Plot) ID() imgui.ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_ImPlotPlot_GetID(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))
		return &result
	}())
}

func (self *Plot) Flags() Flags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Flags(C.wrap_ImPlotPlot_GetFlags(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) PreviousFlags() Flags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Flags(C.wrap_ImPlotPlot_GetPreviousFlags(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) MouseTextLocation() Location {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Location(C.wrap_ImPlotPlot_GetMouseTextLocation(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) MouseTextFlags() MouseTextFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return MouseTextFlags(C.wrap_ImPlotPlot_GetMouseTextFlags(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) Axes() [6]Axis {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [6]Axis {
		result := [6]Axis{}
		resultMirr := C.wrap_ImPlotPlot_GetAxes(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))
		for i := range result {
			result[i] = *NewAxisFromC(func() *C.ImPlotAxis { result := C.implot_ImPlotAxis_GetAtIdx(resultMirr, C.int(i)); return &result }())
		}

		return result
	}()
}

func (self *Plot) TextBuffer() imgui.TextBuffer {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewTextBufferFromC(func() *C.ImGuiTextBuffer {
		result := C.wrap_ImPlotPlot_GetTextBuffer(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))
		return &result
	}())
}

func (self *Plot) Items() ItemGroup {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotPlot_GetItems(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewItemGroupFromC(func() *C.ImPlotItemGroup { result := result; return &result }())
}

func (self *Plot) CurrentX() AxisEnum {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return AxisEnum(C.wrap_ImPlotPlot_GetCurrentX(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) CurrentY() AxisEnum {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return AxisEnum(C.wrap_ImPlotPlot_GetCurrentY(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) FrameRect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotPlot_GetFrameRect(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Plot) CanvasRect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotPlot_GetCanvasRect(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Plot) PlotRect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotPlot_GetPlotRect(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Plot) AxesRect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotPlot_GetAxesRect(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Plot) SelectRect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotPlot_GetSelectRect(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Plot) SelectStart() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotPlot_GetSelectStart(internal.ReinterpretCast[*C.ImPlotPlot](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Plot) TitleOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotPlot_GetTitleOffset(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)))
}

func (self *Plot) JustCreated() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotPlot_GetJustCreated(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self *Plot) Initialized() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotPlot_GetInitialized(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self *Plot) SetupLocked() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotPlot_GetSetupLocked(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self *Plot) FitThisFrame() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotPlot_GetFitThisFrame(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self *Plot) Hovered() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotPlot_GetHovered(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self *Plot) Held() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotPlot_GetHeld(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self *Plot) Selecting() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotPlot_GetSelecting(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self *Plot) Selected() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotPlot_GetSelected(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self *Plot) ContextLocked() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotPlot_GetContextLocked(internal.ReinterpretCast[*C.ImPlotPlot](selfArg)) == C.bool(true)
}

func (self PointError) SetX(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPointError_SetX(selfArg, C.double(v))
}

func (self PointError) SetY(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPointError_SetY(selfArg, C.double(v))
}

func (self PointError) SetNeg(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPointError_SetNeg(selfArg, C.double(v))
}

func (self PointError) SetPos(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotPointError_SetPos(selfArg, C.double(v))
}

func (self *PointError) X() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotPointError_GetX(internal.ReinterpretCast[*C.ImPlotPointError](selfArg)))
}

func (self *PointError) Y() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotPointError_GetY(internal.ReinterpretCast[*C.ImPlotPointError](selfArg)))
}

func (self *PointError) Neg() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotPointError_GetNeg(internal.ReinterpretCast[*C.ImPlotPointError](selfArg)))
}

func (self *PointError) Pos() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotPointError_GetPos(internal.ReinterpretCast[*C.ImPlotPointError](selfArg)))
}

func (self Range) SetMin(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotRange_SetMin(selfArg, C.double(v))
}

func (self Range) SetMax(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotRange_SetMax(selfArg, C.double(v))
}

func (self *Range) Min() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotRange_GetMin(internal.ReinterpretCast[*C.ImPlotRange](selfArg)))
}

func (self *Range) Max() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotRange_GetMax(internal.ReinterpretCast[*C.ImPlotRange](selfArg)))
}

func (self Rect) SetX(v Range) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotRect_SetX(selfArg, internal.ReinterpretCast[C.ImPlotRange](vArg))
}

func (self Rect) SetY(v Range) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotRect_SetY(selfArg, internal.ReinterpretCast[C.ImPlotRange](vArg))
}

func (self *Rect) X() Range {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotRect_GetX(internal.ReinterpretCast[*C.ImPlotRect](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewRangeFromC(func() *C.ImPlotRange { result := result; return &result }())
}

func (self *Rect) Y() Range {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotRect_GetY(internal.ReinterpretCast[*C.ImPlotRect](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewRangeFromC(func() *C.ImPlotRange { result := result; return &result }())
}

func (self Style) SetLineWeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetLineWeight(selfArg, C.float(v))
}

func (self Style) SetMarker(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMarker(selfArg, C.int(v))
}

func (self Style) SetMarkerSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMarkerSize(selfArg, C.float(v))
}

func (self Style) SetMarkerWeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMarkerWeight(selfArg, C.float(v))
}

func (self Style) SetFillAlpha(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetFillAlpha(selfArg, C.float(v))
}

func (self Style) SetErrorBarSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetErrorBarSize(selfArg, C.float(v))
}

func (self Style) SetErrorBarWeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetErrorBarWeight(selfArg, C.float(v))
}

func (self Style) SetDigitalBitHeight(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetDigitalBitHeight(selfArg, C.float(v))
}

func (self Style) SetDigitalBitGap(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetDigitalBitGap(selfArg, C.float(v))
}

func (self Style) SetPlotBorderSize(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetPlotBorderSize(selfArg, C.float(v))
}

func (self Style) SetMinorAlpha(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMinorAlpha(selfArg, C.float(v))
}

func (self Style) SetMajorTickLen(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMajorTickLen(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetMinorTickLen(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMinorTickLen(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetMajorTickSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMajorTickSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetMinorTickSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMinorTickSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetMajorGridSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMajorGridSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetMinorGridSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMinorGridSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetPlotPadding(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetPlotPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetLabelPadding(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetLabelPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetLegendPadding(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetLegendPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetLegendInnerPadding(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetLegendInnerPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetLegendSpacing(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetLegendSpacing(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetMousePosPadding(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetMousePosPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetAnnotationPadding(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetAnnotationPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetFitPadding(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetFitPadding(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetPlotDefaultSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetPlotDefaultSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetPlotMinSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetPlotMinSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Style) SetColors(v *[21]imgui.Vec4) {
	vArg := make([]C.ImVec4, len(v))
	for i, vV := range v {
		vArg[i] = internal.ReinterpretCast[C.ImVec4](vV.ToC())
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetColors(selfArg, (*C.ImVec4)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = func() imgui.Vec4 { out := vV; return *(&imgui.Vec4{}).FromC(unsafe.Pointer(&out)) }()
	}
}

func (self Style) SetColormap(v Colormap) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetColormap(selfArg, C.ImPlotColormap(v))
}

func (self Style) SetUseLocalTime(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetUseLocalTime(selfArg, C.bool(v))
}

func (self Style) SetUseISO8601(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetUseISO8601(selfArg, C.bool(v))
}

func (self Style) SetUse24HourClock(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotStyle_SetUse24HourClock(selfArg, C.bool(v))
}

func (self *Style) LineWeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetLineWeight(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) Marker() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotStyle_GetMarker(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) MarkerSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetMarkerSize(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) MarkerWeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetMarkerWeight(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) FillAlpha() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetFillAlpha(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) ErrorBarSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetErrorBarSize(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) ErrorBarWeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetErrorBarWeight(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) DigitalBitHeight() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetDigitalBitHeight(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) DigitalBitGap() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetDigitalBitGap(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) PlotBorderSize() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetPlotBorderSize(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) MinorAlpha() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotStyle_GetMinorAlpha(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) MajorTickLen() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetMajorTickLen(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) MinorTickLen() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetMinorTickLen(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) MajorTickSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetMajorTickSize(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) MinorTickSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetMinorTickSize(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) MajorGridSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetMajorGridSize(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) MinorGridSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetMinorGridSize(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) PlotPadding() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetPlotPadding(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) LabelPadding() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetLabelPadding(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) LegendPadding() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetLegendPadding(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) LegendInnerPadding() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetLegendInnerPadding(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) LegendSpacing() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetLegendSpacing(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) MousePosPadding() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetMousePosPadding(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) AnnotationPadding() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetAnnotationPadding(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) FitPadding() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetFitPadding(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) PlotDefaultSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetPlotDefaultSize(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) PlotMinSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotStyle_GetPlotMinSize(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Style) Colors() [21]imgui.Vec4 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [21]imgui.Vec4 {
		result := [21]imgui.Vec4{}
		resultMirr := C.wrap_ImPlotStyle_GetColors(internal.ReinterpretCast[*C.ImPlotStyle](selfArg))
		for i := range result {
			result[i] = func() imgui.Vec4 {
				out := C.implot_ImVec4_GetAtIdx(resultMirr, C.int(i))
				return *(&imgui.Vec4{}).FromC(unsafe.Pointer(&out))
			}()
		}

		return result
	}()
}

func (self *Style) Colormap() Colormap {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return Colormap(C.wrap_ImPlotStyle_GetColormap(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)))
}

func (self *Style) UseLocalTime() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotStyle_GetUseLocalTime(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)) == C.bool(true)
}

func (self *Style) UseISO8601() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotStyle_GetUseISO8601(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)) == C.bool(true)
}

func (self *Style) Use24HourClock() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotStyle_GetUse24HourClock(internal.ReinterpretCast[*C.ImPlotStyle](selfArg)) == C.bool(true)
}

func (self Subplot) SetID(v imgui.ID) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetID(selfArg, internal.ReinterpretCast[C.ImGuiID](vArg))
}

func (self Subplot) SetFlags(v SubplotFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetFlags(selfArg, C.ImPlotSubplotFlags(v))
}

func (self Subplot) SetPreviousFlags(v SubplotFlags) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetPreviousFlags(selfArg, C.ImPlotSubplotFlags(v))
}

func (self Subplot) SetItems(v ItemGroup) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetItems(selfArg, internal.ReinterpretCast[C.ImPlotItemGroup](vArg))
}

func (self Subplot) SetRows(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetRows(selfArg, C.int(v))
}

func (self Subplot) SetCols(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetCols(selfArg, C.int(v))
}

func (self Subplot) SetCurrentIdx(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetCurrentIdx(selfArg, C.int(v))
}

func (self Subplot) SetFrameRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetFrameRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Subplot) SetGridRect(v imgui.Rect) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetGridRect(selfArg, internal.ReinterpretCast[C.ImRect](v.ToC()))
}

func (self Subplot) SetCellSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetCellSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Subplot) SetRowAlignmentData(v vectors.Vector[AlignmentData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImPlotAlignmentData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImPlotAlignmentData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetRowAlignmentData(selfArg, *vVecArg)
}

func (self Subplot) SetColAlignmentData(v vectors.Vector[AlignmentData]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImPlotAlignmentData)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImPlotAlignmentData](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetColAlignmentData(selfArg, *vVecArg)
}

func (self Subplot) SetRowRatios(v vectors.Vector[float32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.float, float32](vData)
	vVecArg := new(C.ImVector_float)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetRowRatios(selfArg, *vVecArg)
}

func (self Subplot) SetColRatios(v vectors.Vector[float32]) {
	vData := v.Data
	vDataArg, _ := internal.WrapNumberPtr[C.float, float32](vData)
	vVecArg := new(C.ImVector_float)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = vDataArg
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetColRatios(selfArg, *vVecArg)
}

func (self Subplot) SetRowLinkData(v vectors.Vector[Range]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImPlotRange)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImPlotRange](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetRowLinkData(selfArg, *vVecArg)
}

func (self Subplot) SetColLinkData(v vectors.Vector[Range]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImPlotRange)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImPlotRange](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetColLinkData(selfArg, *vVecArg)
}

func (self Subplot) SetTempSizes(v *[2]float32) {
	vArg := make([]C.float, len(v))
	for i, vV := range v {
		vArg[i] = C.float(vV)
	}

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetTempSizes(selfArg, (*C.float)(&vArg[0]))

	for i, vV := range vArg {
		(*v)[i] = float32(vV)
	}
}

func (self Subplot) SetFrameHovered(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetFrameHovered(selfArg, C.bool(v))
}

func (self Subplot) SetHasTitle(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotSubplot_SetHasTitle(selfArg, C.bool(v))
}

func (self *Subplot) ID() imgui.ID {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewIDFromC(func() *C.ImGuiID {
		result := C.wrap_ImPlotSubplot_GetID(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg))
		return &result
	}())
}

func (self *Subplot) Flags() SubplotFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return SubplotFlags(C.wrap_ImPlotSubplot_GetFlags(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)))
}

func (self *Subplot) PreviousFlags() SubplotFlags {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return SubplotFlags(C.wrap_ImPlotSubplot_GetPreviousFlags(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)))
}

func (self *Subplot) Items() ItemGroup {
	selfArg, selfFin := self.Handle()

	result := C.wrap_ImPlotSubplot_GetItems(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg))

	defer func() {
		selfFin()
	}()
	return *NewItemGroupFromC(func() *C.ImPlotItemGroup { result := result; return &result }())
}

func (self *Subplot) Rows() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotSubplot_GetRows(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)))
}

func (self *Subplot) Cols() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotSubplot_GetCols(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)))
}

func (self *Subplot) CurrentIdx() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotSubplot_GetCurrentIdx(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)))
}

func (self *Subplot) FrameRect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotSubplot_GetFrameRect(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Subplot) GridRect() imgui.Rect {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Rect {
		out := C.wrap_ImPlotSubplot_GetGridRect(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg))
		return *(&imgui.Rect{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Subplot) CellSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotSubplot_GetCellSize(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Subplot) RowAlignmentData() vectors.Vector[AlignmentData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotSubplot_GetRowAlignmentData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Size, C.wrap_ImPlotSubplot_GetRowAlignmentData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Capacity, NewAlignmentDataFromC(C.wrap_ImPlotSubplot_GetRowAlignmentData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Data))
}

func (self *Subplot) ColAlignmentData() vectors.Vector[AlignmentData] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotSubplot_GetColAlignmentData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Size, C.wrap_ImPlotSubplot_GetColAlignmentData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Capacity, NewAlignmentDataFromC(C.wrap_ImPlotSubplot_GetColAlignmentData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Data))
}

func (self *Subplot) RowRatios() vectors.Vector[float32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotSubplot_GetRowRatios(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Size, C.wrap_ImPlotSubplot_GetRowRatios(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Capacity, (*float32)(C.wrap_ImPlotSubplot_GetRowRatios(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Data))
}

func (self *Subplot) ColRatios() vectors.Vector[float32] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotSubplot_GetColRatios(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Size, C.wrap_ImPlotSubplot_GetColRatios(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Capacity, (*float32)(C.wrap_ImPlotSubplot_GetColRatios(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Data))
}

func (self *Subplot) RowLinkData() vectors.Vector[Range] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotSubplot_GetRowLinkData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Size, C.wrap_ImPlotSubplot_GetRowLinkData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Capacity, NewRangeFromC(C.wrap_ImPlotSubplot_GetRowLinkData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Data))
}

func (self *Subplot) ColLinkData() vectors.Vector[Range] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotSubplot_GetColLinkData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Size, C.wrap_ImPlotSubplot_GetColLinkData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Capacity, NewRangeFromC(C.wrap_ImPlotSubplot_GetColLinkData(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)).Data))
}

func (self *Subplot) TempSizes() [2]float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() [2]float32 {
		result := [2]float32{}
		resultMirr := C.wrap_ImPlotSubplot_GetTempSizes(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg))
		for i := range result {
			result[i] = float32(C.implot_float_GetAtIdx(resultMirr, C.int(i)))
		}

		return result
	}()
}

func (self *Subplot) FrameHovered() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotSubplot_GetFrameHovered(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)) == C.bool(true)
}

func (self *Subplot) HasTitle() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotSubplot_GetHasTitle(internal.ReinterpretCast[*C.ImPlotSubplot](selfArg)) == C.bool(true)
}

func (self Tag) SetAxis(v AxisEnum) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTag_SetAxis(selfArg, C.ImAxis(v))
}

func (self Tag) SetValue(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTag_SetValue(selfArg, C.double(v))
}

func (self Tag) SetColorBg(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTag_SetColorBg(selfArg, C.ImU32(v))
}

func (self Tag) SetColorFg(v uint32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTag_SetColorFg(selfArg, C.ImU32(v))
}

func (self Tag) SetTextOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTag_SetTextOffset(selfArg, C.int(v))
}

func (self *Tag) Axis() AxisEnum {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return AxisEnum(C.wrap_ImPlotTag_GetAxis(internal.ReinterpretCast[*C.ImPlotTag](selfArg)))
}

func (self *Tag) Value() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotTag_GetValue(internal.ReinterpretCast[*C.ImPlotTag](selfArg)))
}

func (self *Tag) ColorBg() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotTag_GetColorBg(internal.ReinterpretCast[*C.ImPlotTag](selfArg)))
}

func (self *Tag) ColorFg() uint32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return (uint32)(C.wrap_ImPlotTag_GetColorFg(internal.ReinterpretCast[*C.ImPlotTag](selfArg)))
}

func (self *Tag) TextOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotTag_GetTextOffset(internal.ReinterpretCast[*C.ImPlotTag](selfArg)))
}

func (self TagCollection) SetTags(v vectors.Vector[Tag]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImPlotTag)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImPlotTag](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTagCollection_SetTags(selfArg, *vVecArg)
}

func (self TagCollection) SetTextBuffer(v imgui.TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTagCollection_SetTextBuffer(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self TagCollection) SetSize(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTagCollection_SetSize(selfArg, C.int(v))
}

func (self *TagCollection) Tags() vectors.Vector[Tag] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotTagCollection_GetTags(internal.ReinterpretCast[*C.ImPlotTagCollection](selfArg)).Size, C.wrap_ImPlotTagCollection_GetTags(internal.ReinterpretCast[*C.ImPlotTagCollection](selfArg)).Capacity, NewTagFromC(C.wrap_ImPlotTagCollection_GetTags(internal.ReinterpretCast[*C.ImPlotTagCollection](selfArg)).Data))
}

func (self *TagCollection) TextBuffer() imgui.TextBuffer {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewTextBufferFromC(func() *C.ImGuiTextBuffer {
		result := C.wrap_ImPlotTagCollection_GetTextBuffer(internal.ReinterpretCast[*C.ImPlotTagCollection](selfArg))
		return &result
	}())
}

func (self *TagCollection) Size() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotTagCollection_GetSize(internal.ReinterpretCast[*C.ImPlotTagCollection](selfArg)))
}

func (self Tick) SetPlotPos(v float64) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTick_SetPlotPos(selfArg, C.double(v))
}

func (self Tick) SetPixelPos(v float32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTick_SetPixelPos(selfArg, C.float(v))
}

func (self Tick) SetLabelSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTick_SetLabelSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Tick) SetTextOffset(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTick_SetTextOffset(selfArg, C.int(v))
}

func (self Tick) SetMajor(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTick_SetMajor(selfArg, C.bool(v))
}

func (self Tick) SetShowLabel(v bool) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTick_SetShowLabel(selfArg, C.bool(v))
}

func (self Tick) SetLevel(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTick_SetLevel(selfArg, C.int(v))
}

func (self Tick) SetIdx(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTick_SetIdx(selfArg, C.int(v))
}

func (self *Tick) PlotPos() float64 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float64(C.wrap_ImPlotTick_GetPlotPos(internal.ReinterpretCast[*C.ImPlotTick](selfArg)))
}

func (self *Tick) PixelPos() float32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return float32(C.wrap_ImPlotTick_GetPixelPos(internal.ReinterpretCast[*C.ImPlotTick](selfArg)))
}

func (self *Tick) LabelSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotTick_GetLabelSize(internal.ReinterpretCast[*C.ImPlotTick](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Tick) TextOffset() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotTick_GetTextOffset(internal.ReinterpretCast[*C.ImPlotTick](selfArg)))
}

func (self *Tick) Major() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotTick_GetMajor(internal.ReinterpretCast[*C.ImPlotTick](selfArg)) == C.bool(true)
}

func (self *Tick) ShowLabel() bool {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return C.wrap_ImPlotTick_GetShowLabel(internal.ReinterpretCast[*C.ImPlotTick](selfArg)) == C.bool(true)
}

func (self *Tick) Level() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotTick_GetLevel(internal.ReinterpretCast[*C.ImPlotTick](selfArg)))
}

func (self *Tick) Idx() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotTick_GetIdx(internal.ReinterpretCast[*C.ImPlotTick](selfArg)))
}

func (self Ticker) SetTicks(v vectors.Vector[Tick]) {
	vData := v.Data
	vDataArg, _ := vData.Handle()
	vVecArg := new(C.ImVector_ImPlotTick)
	vVecArg.Size = C.int(v.Size)
	vVecArg.Capacity = C.int(v.Capacity)
	vVecArg.Data = internal.ReinterpretCast[*C.ImPlotTick](vDataArg)
	v.Pinner().Pin(vVecArg.Data)

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTicker_SetTicks(selfArg, *vVecArg)
}

func (self Ticker) SetTextBuffer(v imgui.TextBuffer) {
	vArg, _ := v.C()

	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTicker_SetTextBuffer(selfArg, internal.ReinterpretCast[C.ImGuiTextBuffer](vArg))
}

func (self Ticker) SetMaxSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTicker_SetMaxSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Ticker) SetLateSize(v imgui.Vec2) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTicker_SetLateSize(selfArg, internal.ReinterpretCast[C.ImVec2](v.ToC()))
}

func (self Ticker) SetLevels(v int32) {
	selfArg, selfFin := self.Handle()
	defer selfFin()
	C.wrap_ImPlotTicker_SetLevels(selfArg, C.int(v))
}

func (self *Ticker) Ticks() vectors.Vector[Tick] {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return vectors.NewVectorFromC(C.wrap_ImPlotTicker_GetTicks(internal.ReinterpretCast[*C.ImPlotTicker](selfArg)).Size, C.wrap_ImPlotTicker_GetTicks(internal.ReinterpretCast[*C.ImPlotTicker](selfArg)).Capacity, NewTickFromC(C.wrap_ImPlotTicker_GetTicks(internal.ReinterpretCast[*C.ImPlotTicker](selfArg)).Data))
}

func (self *Ticker) TextBuffer() imgui.TextBuffer {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return *imgui.NewTextBufferFromC(func() *C.ImGuiTextBuffer {
		result := C.wrap_ImPlotTicker_GetTextBuffer(internal.ReinterpretCast[*C.ImPlotTicker](selfArg))
		return &result
	}())
}

func (self *Ticker) MaxSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotTicker_GetMaxSize(internal.ReinterpretCast[*C.ImPlotTicker](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Ticker) LateSize() imgui.Vec2 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return func() imgui.Vec2 {
		out := C.wrap_ImPlotTicker_GetLateSize(internal.ReinterpretCast[*C.ImPlotTicker](selfArg))
		return *(&imgui.Vec2{}).FromC(unsafe.Pointer(&out))
	}()
}

func (self *Ticker) Levels() int32 {
	selfArg, selfFin := self.Handle()

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotTicker_GetLevels(internal.ReinterpretCast[*C.ImPlotTicker](selfArg)))
}

func (self *PlotTime) S() uint64 {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return uint64(C.wrap_ImPlotTime_GetS(internal.ReinterpretCast[*C.ImPlotTime](selfArg)))
}

func (self *PlotTime) Us() int32 {
	selfArg, selfFin := internal.Wrap(self)

	defer func() {
		selfFin()
	}()
	return int32(C.wrap_ImPlotTime_GetUs(internal.ReinterpretCast[*C.ImPlotTime](selfArg)))
}
