// THIS FILE HAS BEEN AUTO-GENERATED BY THE 'DEAR BINDINGS' GENERATOR.
// **DO NOT EDIT DIRECTLY**
// https://github.com/dearimgui/dear_bindings

// THIS FILE HAS BEEN AUTO-GENERATED BY THE 'DEAR BINDINGS' GENERATOR.
// **DO NOT EDIT DIRECTLY**
// https://github.com/dearimgui/dear_bindings

// By-value struct conversions

// Function stubs
#include "cimplot.h"

CIMGUI_API bool   cimgui::ImPlotRange_Contains(const cimgui::ImPlotRange* self, double value)
{
    return reinterpret_cast<const ::ImPlotRange*>(self)->Contains(value);
}

CIMGUI_API double cimgui::ImPlotRange_Size(const cimgui::ImPlotRange* self)
{
    return reinterpret_cast<const ::ImPlotRange*>(self)->Size();
}

CIMGUI_API double cimgui::ImPlotRange_Clamp(const cimgui::ImPlotRange* self, double value)
{
    return reinterpret_cast<const ::ImPlotRange*>(self)->Clamp(value);
}

CIMGUI_API bool        cimgui::ImPlotRect_Contains(const cimgui::ImPlotRect* self, cimgui::ImPlotPoint p)
{
    return reinterpret_cast<const ::ImPlotRect*>(self)->Contains(reinterpret_cast<const ::ImPlotPoint&>(p));
}

CIMGUI_API bool        cimgui::ImPlotRect_ContainsDouble(const cimgui::ImPlotRect* self, double x, double y)
{
    return reinterpret_cast<const ::ImPlotRect*>(self)->Contains(x, y);
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotRect_Size(const cimgui::ImPlotRect* self)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(reinterpret_cast<const ::ImPlotRect*>(self)->Size());
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotRect_Clamp(cimgui::ImPlotRect* self, cimgui::ImPlotPoint p)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(reinterpret_cast<::ImPlotRect*>(self)->Clamp(reinterpret_cast<const ::ImPlotPoint&>(p)));
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotRect_ClampDouble(cimgui::ImPlotRect* self, double x, double y)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(reinterpret_cast<::ImPlotRect*>(self)->Clamp(x, y));
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotRect_Min(const cimgui::ImPlotRect* self)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(reinterpret_cast<const ::ImPlotRect*>(self)->Min());
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotRect_Max(const cimgui::ImPlotRect* self)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(reinterpret_cast<const ::ImPlotRect*>(self)->Max());
}

CIMGUI_API IMPLOT_API cimgui::ImPlotStyle_ImPlotStyle(cimgui::ImPlotStyle* self)
{
    return reinterpret_cast<::ImPlotStyle*>(self)->ImPlotStyle();
}

CIMGUI_API IMPLOT_API cimgui::ImPlotInputMap_ImPlotInputMap(cimgui::ImPlotInputMap* self)
{
    return reinterpret_cast<::ImPlotInputMap*>(self)->ImPlotInputMap();
}

CIMGUI_API cimgui::ImPlotContext* cimgui::ImPlotCreateContext(void)
{
    return reinterpret_cast<::cimgui::ImPlotContext*>(::ImPlot::CreateContext());
}

CIMGUI_API void           cimgui::ImPlotDestroyContext(void)
{
    ::ImPlot::DestroyContext();
}

CIMGUI_API void           cimgui::ImPlotDestroyContextEx(cimgui::ImPlotContext* ctx)
{
    ::ImPlot::DestroyContext(reinterpret_cast<::ImPlotContext*>(ctx));
}

CIMGUI_API cimgui::ImPlotContext* cimgui::ImPlotGetCurrentContext(void)
{
    return reinterpret_cast<::cimgui::ImPlotContext*>(::ImPlot::GetCurrentContext());
}

CIMGUI_API void           cimgui::ImPlotSetCurrentContext(cimgui::ImPlotContext* ctx)
{
    ::ImPlot::SetCurrentContext(reinterpret_cast<::ImPlotContext*>(ctx));
}

CIMGUI_API void cimgui::ImPlotSetImGuiContext(ImGuiContext* ctx)
{
    ::ImPlot::SetImGuiContext(ctx);
}

CIMGUI_API bool cimgui::ImPlotBeginPlot(const char* title_id)
{
    return ::ImPlot::BeginPlot(title_id);
}

CIMGUI_API bool cimgui::ImPlotBeginPlotEx(const char* title_id, ImVec2 size, ImPlotFlags flags)
{
    return ::ImPlot::BeginPlot(title_id, reinterpret_cast<const ::ImVec2&>(size), flags);
}

CIMGUI_API void cimgui::ImPlotEndPlot(void)
{
    ::ImPlot::EndPlot();
}

CIMGUI_API bool cimgui::ImPlotBeginSubplots(const char* title_id, int rows, int cols, ImVec2 size, ImPlotSubplotFlags flags)
{
    return ::ImPlot::BeginSubplots(title_id, rows, cols, reinterpret_cast<const ::ImVec2&>(size), flags);
}

CIMGUI_API bool cimgui::ImPlotBeginSubplotsEx(const char* title_id, int rows, int cols, ImVec2 size, ImPlotSubplotFlags flags, float* row_ratios, float* col_ratios)
{
    return ::ImPlot::BeginSubplots(title_id, rows, cols, reinterpret_cast<const ::ImVec2&>(size), flags, row_ratios, col_ratios);
}

CIMGUI_API void cimgui::ImPlotEndSubplots(void)
{
    ::ImPlot::EndSubplots();
}

CIMGUI_API void cimgui::ImPlotSetupAxis(ImAxis axis)
{
    ::ImPlot::SetupAxis(axis);
}

CIMGUI_API void cimgui::ImPlotSetupAxisEx(ImAxis axis, const char* label, ImPlotAxisFlags flags)
{
    ::ImPlot::SetupAxis(axis, label, flags);
}

CIMGUI_API void cimgui::ImPlotSetupAxisLimits(ImAxis axis, double v_min, double v_max)
{
    ::ImPlot::SetupAxisLimits(axis, v_min, v_max);
}

CIMGUI_API void cimgui::ImPlotSetupAxisLimitsEx(ImAxis axis, double v_min, double v_max, ImPlotCond cond)
{
    ::ImPlot::SetupAxisLimits(axis, v_min, v_max, cond);
}

CIMGUI_API void cimgui::ImPlotSetupAxisLinks(ImAxis axis, double* link_min, double* link_max)
{
    ::ImPlot::SetupAxisLinks(axis, link_min, link_max);
}

CIMGUI_API void cimgui::ImPlotSetupAxisFormat(ImAxis axis, const char* fmt)
{
    ::ImPlot::SetupAxisFormat(axis, fmt);
}

CIMGUI_API void cimgui::ImPlotSetupAxisFormatImPlotFormatter(ImAxis axis, cimgui::ImPlotFormatter formatter)
{
    ::ImPlot::SetupAxisFormat(axis, reinterpret_cast<::ImPlotFormatter>(formatter));
}

CIMGUI_API void cimgui::ImPlotSetupAxisFormatImPlotFormatterEx(ImAxis axis, cimgui::ImPlotFormatter formatter, void* data)
{
    ::ImPlot::SetupAxisFormat(axis, reinterpret_cast<::ImPlotFormatter>(formatter), data);
}

CIMGUI_API void cimgui::ImPlotSetupAxisTicks(ImAxis axis, const double* values, int n_ticks)
{
    ::ImPlot::SetupAxisTicks(axis, values, n_ticks);
}

CIMGUI_API void cimgui::ImPlotSetupAxisTicksEx(ImAxis axis, const double* values, int n_ticks, const char*const labels[], bool keep_default)
{
    ::ImPlot::SetupAxisTicks(axis, values, n_ticks, labels, keep_default);
}

CIMGUI_API void cimgui::ImPlotSetupAxisTicksDouble(ImAxis axis, double v_min, double v_max, int n_ticks)
{
    ::ImPlot::SetupAxisTicks(axis, v_min, v_max, n_ticks);
}

CIMGUI_API void cimgui::ImPlotSetupAxisTicksDoubleEx(ImAxis axis, double v_min, double v_max, int n_ticks, const char*const labels[], bool keep_default)
{
    ::ImPlot::SetupAxisTicks(axis, v_min, v_max, n_ticks, labels, keep_default);
}

CIMGUI_API void cimgui::ImPlotSetupAxisScale(ImAxis axis, ImPlotScale scale)
{
    ::ImPlot::SetupAxisScale(axis, scale);
}

CIMGUI_API void cimgui::ImPlotSetupAxisScaleImPlotTransform(ImAxis axis, cimgui::ImPlotTransform forward, cimgui::ImPlotTransform inverse)
{
    ::ImPlot::SetupAxisScale(axis, reinterpret_cast<::ImPlotTransform>(forward), reinterpret_cast<::ImPlotTransform>(inverse));
}

CIMGUI_API void cimgui::ImPlotSetupAxisScaleImPlotTransformEx(ImAxis axis, cimgui::ImPlotTransform forward, cimgui::ImPlotTransform inverse, void* data)
{
    ::ImPlot::SetupAxisScale(axis, reinterpret_cast<::ImPlotTransform>(forward), reinterpret_cast<::ImPlotTransform>(inverse), data);
}

CIMGUI_API void cimgui::ImPlotSetupAxisLimitsConstraints(ImAxis axis, double v_min, double v_max)
{
    ::ImPlot::SetupAxisLimitsConstraints(axis, v_min, v_max);
}

CIMGUI_API void cimgui::ImPlotSetupAxisZoomConstraints(ImAxis axis, double z_min, double z_max)
{
    ::ImPlot::SetupAxisZoomConstraints(axis, z_min, z_max);
}

CIMGUI_API void cimgui::ImPlotSetupAxes(const char* x_label, const char* y_label)
{
    ::ImPlot::SetupAxes(x_label, y_label);
}

CIMGUI_API void cimgui::ImPlotSetupAxesEx(const char* x_label, const char* y_label, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags)
{
    ::ImPlot::SetupAxes(x_label, y_label, x_flags, y_flags);
}

CIMGUI_API void cimgui::ImPlotSetupAxesLimits(double x_min, double x_max, double y_min, double y_max)
{
    ::ImPlot::SetupAxesLimits(x_min, x_max, y_min, y_max);
}

CIMGUI_API void cimgui::ImPlotSetupAxesLimitsEx(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond)
{
    ::ImPlot::SetupAxesLimits(x_min, x_max, y_min, y_max, cond);
}

CIMGUI_API void cimgui::ImPlotSetupLegend(ImPlotLocation location, ImPlotLegendFlags flags)
{
    ::ImPlot::SetupLegend(location, flags);
}

CIMGUI_API void cimgui::ImPlotSetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flags)
{
    ::ImPlot::SetupMouseText(location, flags);
}

CIMGUI_API void cimgui::ImPlotSetupFinish(void)
{
    ::ImPlot::SetupFinish();
}

CIMGUI_API void cimgui::ImPlotSetNextAxisLimits(ImAxis axis, double v_min, double v_max)
{
    ::ImPlot::SetNextAxisLimits(axis, v_min, v_max);
}

CIMGUI_API void cimgui::ImPlotSetNextAxisLimitsEx(ImAxis axis, double v_min, double v_max, ImPlotCond cond)
{
    ::ImPlot::SetNextAxisLimits(axis, v_min, v_max, cond);
}

CIMGUI_API void cimgui::ImPlotSetNextAxisLinks(ImAxis axis, double* link_min, double* link_max)
{
    ::ImPlot::SetNextAxisLinks(axis, link_min, link_max);
}

CIMGUI_API void cimgui::ImPlotSetNextAxisToFit(ImAxis axis)
{
    ::ImPlot::SetNextAxisToFit(axis);
}

CIMGUI_API void cimgui::ImPlotSetNextAxesLimits(double x_min, double x_max, double y_min, double y_max)
{
    ::ImPlot::SetNextAxesLimits(x_min, x_max, y_min, y_max);
}

CIMGUI_API void cimgui::ImPlotSetNextAxesLimitsEx(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond)
{
    ::ImPlot::SetNextAxesLimits(x_min, x_max, y_min, y_max, cond);
}

CIMGUI_API void cimgui::ImPlotSetNextAxesToFit(void)
{
    ::ImPlot::SetNextAxesToFit();
}

CIMGUI_API void cimgui::ImPlotPlotLineInt(const char* label_id, const T* values, int count)
{
    ::ImPlot::PlotLine(label_id, values, count);
}

CIMGUI_API void cimgui::ImPlotPlotLineIntEx(const char* label_id, const T* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
{
    ::ImPlot::PlotLine(label_id, values, count, xscale, xstart, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotLine(const char* label_id, const T* xs, const T* ys, int count, ImPlotLineFlags flags)
{
    ::ImPlot::PlotLine(label_id, xs, ys, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotLineEx(const char* label_id, const T* xs, const T* ys, int count, ImPlotLineFlags flags, int offset, int stride)
{
    ::ImPlot::PlotLine(label_id, xs, ys, count, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotLineG(const char* label_id, cimgui::ImPlotGetter getter, void* data, int count, ImPlotLineFlags flags)
{
    ::ImPlot::PlotLineG(label_id, reinterpret_cast<::ImPlotGetter>(getter), data, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotScatterInt(const char* label_id, const T* values, int count)
{
    ::ImPlot::PlotScatter(label_id, values, count);
}

CIMGUI_API void cimgui::ImPlotPlotScatterIntEx(const char* label_id, const T* values, int count, double xscale, double xstart, ImPlotScatterFlags flags, int offset, int stride)
{
    ::ImPlot::PlotScatter(label_id, values, count, xscale, xstart, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotScatter(const char* label_id, const T* xs, const T* ys, int count, ImPlotScatterFlags flags)
{
    ::ImPlot::PlotScatter(label_id, xs, ys, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotScatterEx(const char* label_id, const T* xs, const T* ys, int count, ImPlotScatterFlags flags, int offset, int stride)
{
    ::ImPlot::PlotScatter(label_id, xs, ys, count, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotScatterG(const char* label_id, cimgui::ImPlotGetter getter, void* data, int count, ImPlotScatterFlags flags)
{
    ::ImPlot::PlotScatterG(label_id, reinterpret_cast<::ImPlotGetter>(getter), data, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotStairsInt(const char* label_id, const T* values, int count)
{
    ::ImPlot::PlotStairs(label_id, values, count);
}

CIMGUI_API void cimgui::ImPlotPlotStairsIntEx(const char* label_id, const T* values, int count, double xscale, double xstart, ImPlotStairsFlags flags, int offset, int stride)
{
    ::ImPlot::PlotStairs(label_id, values, count, xscale, xstart, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotStairs(const char* label_id, const T* xs, const T* ys, int count, ImPlotStairsFlags flags)
{
    ::ImPlot::PlotStairs(label_id, xs, ys, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotStairsEx(const char* label_id, const T* xs, const T* ys, int count, ImPlotStairsFlags flags, int offset, int stride)
{
    ::ImPlot::PlotStairs(label_id, xs, ys, count, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotStairsG(const char* label_id, cimgui::ImPlotGetter getter, void* data, int count, ImPlotStairsFlags flags)
{
    ::ImPlot::PlotStairsG(label_id, reinterpret_cast<::ImPlotGetter>(getter), data, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotShadedInt(const char* label_id, const T* values, int count)
{
    ::ImPlot::PlotShaded(label_id, values, count);
}

CIMGUI_API void cimgui::ImPlotPlotShadedIntEx(const char* label_id, const T* values, int count, double yref, double xscale, double xstart, ImPlotShadedFlags flags, int offset, int stride)
{
    ::ImPlot::PlotShaded(label_id, values, count, yref, xscale, xstart, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotShaded(const char* label_id, const T* xs, const T* ys, int count)
{
    ::ImPlot::PlotShaded(label_id, xs, ys, count);
}

CIMGUI_API void cimgui::ImPlotPlotShadedEx(const char* label_id, const T* xs, const T* ys, int count, double yref, ImPlotShadedFlags flags, int offset, int stride)
{
    ::ImPlot::PlotShaded(label_id, xs, ys, count, yref, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotShadedTPtr(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, ImPlotShadedFlags flags)
{
    ::ImPlot::PlotShaded(label_id, xs, ys1, ys2, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotShadedTPtrEx(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, ImPlotShadedFlags flags, int offset, int stride)
{
    ::ImPlot::PlotShaded(label_id, xs, ys1, ys2, count, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotShadedG(const char* label_id, cimgui::ImPlotGetter getter1, void* data1, cimgui::ImPlotGetter getter2, void* data2, int count, ImPlotShadedFlags flags)
{
    ::ImPlot::PlotShadedG(label_id, reinterpret_cast<::ImPlotGetter>(getter1), data1, reinterpret_cast<::ImPlotGetter>(getter2), data2, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotBars(const char* label_id, const T* values, int count)
{
    ::ImPlot::PlotBars(label_id, values, count);
}

CIMGUI_API void cimgui::ImPlotPlotBarsEx(const char* label_id, const T* values, int count, double bar_size, double shift, ImPlotBarsFlags flags, int offset, int stride)
{
    ::ImPlot::PlotBars(label_id, values, count, bar_size, shift, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotBarsTPtr(const char* label_id, const T* xs, const T* ys, int count, double bar_size, ImPlotBarsFlags flags)
{
    ::ImPlot::PlotBars(label_id, xs, ys, count, bar_size, flags);
}

CIMGUI_API void cimgui::ImPlotPlotBarsTPtrEx(const char* label_id, const T* xs, const T* ys, int count, double bar_size, ImPlotBarsFlags flags, int offset, int stride)
{
    ::ImPlot::PlotBars(label_id, xs, ys, count, bar_size, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotBarsG(const char* label_id, cimgui::ImPlotGetter getter, void* data, int count, double bar_size, ImPlotBarsFlags flags)
{
    ::ImPlot::PlotBarsG(label_id, reinterpret_cast<::ImPlotGetter>(getter), data, count, bar_size, flags);
}

CIMGUI_API void cimgui::ImPlotPlotBarGroups(const char*const label_ids[], const T* values, int item_count, int group_count)
{
    ::ImPlot::PlotBarGroups(label_ids, values, item_count, group_count);
}

CIMGUI_API void cimgui::ImPlotPlotBarGroupsEx(const char*const label_ids[], const T* values, int item_count, int group_count, double group_size, double shift, ImPlotBarGroupsFlags flags)
{
    ::ImPlot::PlotBarGroups(label_ids, values, item_count, group_count, group_size, shift, flags);
}

CIMGUI_API void cimgui::ImPlotPlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, ImPlotErrorBarsFlags flags)
{
    ::ImPlot::PlotErrorBars(label_id, xs, ys, err, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotErrorBarsEx(const char* label_id, const T* xs, const T* ys, const T* err, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
    ::ImPlot::PlotErrorBars(label_id, xs, ys, err, count, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotErrorBarsTPtr(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, ImPlotErrorBarsFlags flags)
{
    ::ImPlot::PlotErrorBars(label_id, xs, ys, neg, pos, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotErrorBarsTPtrEx(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, ImPlotErrorBarsFlags flags, int offset, int stride)
{
    ::ImPlot::PlotErrorBars(label_id, xs, ys, neg, pos, count, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotStemsInt(const char* label_id, const T* values, int count)
{
    ::ImPlot::PlotStems(label_id, values, count);
}

CIMGUI_API void cimgui::ImPlotPlotStemsIntEx(const char* label_id, const T* values, int count, double ref, double scale, double start, ImPlotStemsFlags flags, int offset, int stride)
{
    ::ImPlot::PlotStems(label_id, values, count, ref, scale, start, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotStems(const char* label_id, const T* xs, const T* ys, int count)
{
    ::ImPlot::PlotStems(label_id, xs, ys, count);
}

CIMGUI_API void cimgui::ImPlotPlotStemsEx(const char* label_id, const T* xs, const T* ys, int count, double ref, ImPlotStemsFlags flags, int offset, int stride)
{
    ::ImPlot::PlotStems(label_id, xs, ys, count, ref, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotInfLines(const char* label_id, const T* values, int count, ImPlotInfLinesFlags flags)
{
    ::ImPlot::PlotInfLines(label_id, values, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotInfLinesEx(const char* label_id, const T* values, int count, ImPlotInfLinesFlags flags, int offset, int stride)
{
    ::ImPlot::PlotInfLines(label_id, values, count, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotPieChartImPlotFormatter(const char*const label_ids[], const T* values, int count, double x, double y, double radius, cimgui::ImPlotFormatter fmt)
{
    ::ImPlot::PlotPieChart(label_ids, values, count, x, y, radius, reinterpret_cast<::ImPlotFormatter>(fmt));
}

CIMGUI_API void cimgui::ImPlotPlotPieChartImPlotFormatterEx(const char*const label_ids[], const T* values, int count, double x, double y, double radius, cimgui::ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotPieChartFlags flags)
{
    ::ImPlot::PlotPieChart(label_ids, values, count, x, y, radius, reinterpret_cast<::ImPlotFormatter>(fmt), fmt_data, angle0, flags);
}

CIMGUI_API void cimgui::ImPlotPlotPieChart(const char*const label_ids[], const T* values, int count, double x, double y, double radius)
{
    ::ImPlot::PlotPieChart(label_ids, values, count, x, y, radius);
}

CIMGUI_API void cimgui::ImPlotPlotPieChartEx(const char*const label_ids[], const T* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotPieChartFlags flags)
{
    ::ImPlot::PlotPieChart(label_ids, values, count, x, y, radius, label_fmt, angle0, flags);
}

CIMGUI_API void cimgui::ImPlotPlotHeatmap(const char* label_id, const T* values, int rows, int cols)
{
    ::ImPlot::PlotHeatmap(label_id, values, rows, cols);
}

CIMGUI_API void cimgui::ImPlotPlotHeatmapEx(const char* label_id, const T* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, cimgui::ImPlotPoint bounds_min, cimgui::ImPlotPoint bounds_max, ImPlotHeatmapFlags flags)
{
    ::ImPlot::PlotHeatmap(label_id, values, rows, cols, scale_min, scale_max, label_fmt, reinterpret_cast<const ::ImPlotPoint&>(bounds_min), reinterpret_cast<const ::ImPlotPoint&>(bounds_max), flags);
}

CIMGUI_API double cimgui::ImPlotPlotHistogram(const char* label_id, const T* values, int count)
{
    return ::ImPlot::PlotHistogram(label_id, values, count);
}

CIMGUI_API double cimgui::ImPlotPlotHistogramEx(const char* label_id, const T* values, int count, int bins, double bar_scale, cimgui::ImPlotRange range, ImPlotHistogramFlags flags)
{
    return ::ImPlot::PlotHistogram(label_id, values, count, bins, bar_scale, reinterpret_cast<::ImPlotRange>(range), flags);
}

CIMGUI_API double cimgui::ImPlotPlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count)
{
    return ::ImPlot::PlotHistogram2D(label_id, xs, ys, count);
}

CIMGUI_API double cimgui::ImPlotPlotHistogram2DEx(const char* label_id, const T* xs, const T* ys, int count, int x_bins, int y_bins, cimgui::ImPlotRect range, ImPlotHistogramFlags flags)
{
    return ::ImPlot::PlotHistogram2D(label_id, xs, ys, count, x_bins, y_bins, reinterpret_cast<::ImPlotRect>(range), flags);
}

CIMGUI_API void cimgui::ImPlotPlotDigital(const char* label_id, const T* xs, const T* ys, int count, ImPlotDigitalFlags flags)
{
    ::ImPlot::PlotDigital(label_id, xs, ys, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotDigitalEx(const char* label_id, const T* xs, const T* ys, int count, ImPlotDigitalFlags flags, int offset, int stride)
{
    ::ImPlot::PlotDigital(label_id, xs, ys, count, flags, offset, stride);
}

CIMGUI_API void cimgui::ImPlotPlotDigitalG(const char* label_id, cimgui::ImPlotGetter getter, void* data, int count, ImPlotDigitalFlags flags)
{
    ::ImPlot::PlotDigitalG(label_id, reinterpret_cast<::ImPlotGetter>(getter), data, count, flags);
}

CIMGUI_API void cimgui::ImPlotPlotImage(const char* label_id, ImTextureID user_texture_id, cimgui::ImPlotPoint bounds_min, cimgui::ImPlotPoint bounds_max)
{
    ::ImPlot::PlotImage(label_id, user_texture_id, reinterpret_cast<const ::ImPlotPoint&>(bounds_min), reinterpret_cast<const ::ImPlotPoint&>(bounds_max));
}

CIMGUI_API void cimgui::ImPlotPlotImageEx(const char* label_id, ImTextureID user_texture_id, cimgui::ImPlotPoint bounds_min, cimgui::ImPlotPoint bounds_max, ImVec2 uv0, ImVec2 uv1, ImVec4 tint_col, ImPlotImageFlags flags)
{
    ::ImPlot::PlotImage(label_id, user_texture_id, reinterpret_cast<const ::ImPlotPoint&>(bounds_min), reinterpret_cast<const ::ImPlotPoint&>(bounds_max), reinterpret_cast<const ::ImVec2&>(uv0), reinterpret_cast<const ::ImVec2&>(uv1), reinterpret_cast<const ::ImVec4&>(tint_col), flags);
}

CIMGUI_API void cimgui::ImPlotPlotText(const char* text, double x, double y)
{
    ::ImPlot::PlotText(text, x, y);
}

CIMGUI_API void cimgui::ImPlotPlotTextEx(const char* text, double x, double y, ImVec2 pix_offset, ImPlotTextFlags flags)
{
    ::ImPlot::PlotText(text, x, y, reinterpret_cast<const ::ImVec2&>(pix_offset), flags);
}

CIMGUI_API void cimgui::ImPlotPlotDummy(const char* label_id, ImPlotDummyFlags flags)
{
    ::ImPlot::PlotDummy(label_id, flags);
}

CIMGUI_API bool cimgui::ImPlotDragPoint(int id, double* x, double* y, ImVec4 col)
{
    return ::ImPlot::DragPoint(id, x, y, reinterpret_cast<const ::ImVec4&>(col));
}

CIMGUI_API bool cimgui::ImPlotDragPointEx(int id, double* x, double* y, ImVec4 col, float size, ImPlotDragToolFlags flags, bool* out_clicked, bool* out_hovered, bool* held)
{
    return ::ImPlot::DragPoint(id, x, y, reinterpret_cast<const ::ImVec4&>(col), size, flags, out_clicked, out_hovered, held);
}

CIMGUI_API bool cimgui::ImPlotDragLineX(int id, double* x, ImVec4 col)
{
    return ::ImPlot::DragLineX(id, x, reinterpret_cast<const ::ImVec4&>(col));
}

CIMGUI_API bool cimgui::ImPlotDragLineXEx(int id, double* x, ImVec4 col, float thickness, ImPlotDragToolFlags flags, bool* out_clicked, bool* out_hovered, bool* held)
{
    return ::ImPlot::DragLineX(id, x, reinterpret_cast<const ::ImVec4&>(col), thickness, flags, out_clicked, out_hovered, held);
}

CIMGUI_API bool cimgui::ImPlotDragLineY(int id, double* y, ImVec4 col)
{
    return ::ImPlot::DragLineY(id, y, reinterpret_cast<const ::ImVec4&>(col));
}

CIMGUI_API bool cimgui::ImPlotDragLineYEx(int id, double* y, ImVec4 col, float thickness, ImPlotDragToolFlags flags, bool* out_clicked, bool* out_hovered, bool* held)
{
    return ::ImPlot::DragLineY(id, y, reinterpret_cast<const ::ImVec4&>(col), thickness, flags, out_clicked, out_hovered, held);
}

CIMGUI_API bool cimgui::ImPlotDragRect(int id, double* x1, double* y1, double* x2, double* y2, ImVec4 col, ImPlotDragToolFlags flags)
{
    return ::ImPlot::DragRect(id, x1, y1, x2, y2, reinterpret_cast<const ::ImVec4&>(col), flags);
}

CIMGUI_API bool cimgui::ImPlotDragRectEx(int id, double* x1, double* y1, double* x2, double* y2, ImVec4 col, ImPlotDragToolFlags flags, bool* out_clicked, bool* out_hovered, bool* held)
{
    return ::ImPlot::DragRect(id, x1, y1, x2, y2, reinterpret_cast<const ::ImVec4&>(col), flags, out_clicked, out_hovered, held);
}

CIMGUI_API void cimgui::ImPlotAnnotation(double x, double y, ImVec4 col, ImVec2 pix_offset, bool clamp)
{
    ::ImPlot::Annotation(x, y, reinterpret_cast<const ::ImVec4&>(col), reinterpret_cast<const ::ImVec2&>(pix_offset), clamp);
}

CIMGUI_API void cimgui::ImPlotAnnotationEx(double x, double y, ImVec4 col, ImVec2 pix_offset, bool clamp, bool round)
{
    ::ImPlot::Annotation(x, y, reinterpret_cast<const ::ImVec4&>(col), reinterpret_cast<const ::ImVec2&>(pix_offset), clamp, round);
}

CIMGUI_API void cimgui::ImPlotAnnotationStr(double x, double y, ImVec4 col, ImVec2 pix_offset, bool clamp, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ::ImPlot::AnnotationV(x, y, reinterpret_cast<const ::ImVec4&>(col), reinterpret_cast<const ::ImVec2&>(pix_offset), clamp, fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImPlotAnnotationV(double x, double y, ImVec4 col, ImVec2 pix_offset, bool clamp, const char* fmt, va_list args)
{
    ::ImPlot::AnnotationV(x, y, reinterpret_cast<const ::ImVec4&>(col), reinterpret_cast<const ::ImVec2&>(pix_offset), clamp, fmt, args);
}

CIMGUI_API void cimgui::ImPlotTagX(double x, ImVec4 col)
{
    ::ImPlot::TagX(x, reinterpret_cast<const ::ImVec4&>(col));
}

CIMGUI_API void cimgui::ImPlotTagXEx(double x, ImVec4 col, bool round)
{
    ::ImPlot::TagX(x, reinterpret_cast<const ::ImVec4&>(col), round);
}

CIMGUI_API void cimgui::ImPlotTagXStr(double x, ImVec4 col, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ::ImPlot::TagXV(x, reinterpret_cast<const ::ImVec4&>(col), fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImPlotTagXV(double x, ImVec4 col, const char* fmt, va_list args)
{
    ::ImPlot::TagXV(x, reinterpret_cast<const ::ImVec4&>(col), fmt, args);
}

CIMGUI_API void cimgui::ImPlotTagY(double y, ImVec4 col)
{
    ::ImPlot::TagY(y, reinterpret_cast<const ::ImVec4&>(col));
}

CIMGUI_API void cimgui::ImPlotTagYEx(double y, ImVec4 col, bool round)
{
    ::ImPlot::TagY(y, reinterpret_cast<const ::ImVec4&>(col), round);
}

CIMGUI_API void cimgui::ImPlotTagYStr(double y, ImVec4 col, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    ::ImPlot::TagYV(y, reinterpret_cast<const ::ImVec4&>(col), fmt, args);
    va_end(args);
}

CIMGUI_API void cimgui::ImPlotTagYV(double y, ImVec4 col, const char* fmt, va_list args)
{
    ::ImPlot::TagYV(y, reinterpret_cast<const ::ImVec4&>(col), fmt, args);
}

CIMGUI_API void cimgui::ImPlotSetAxis(ImAxis axis)
{
    ::ImPlot::SetAxis(axis);
}

CIMGUI_API void cimgui::ImPlotSetAxes(ImAxis x_axis, ImAxis y_axis)
{
    ::ImPlot::SetAxes(x_axis, y_axis);
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotPixelsToPlot(ImVec2 pix)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(::ImPlot::PixelsToPlot(reinterpret_cast<const ::ImVec2&>(pix)));
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotPixelsToPlotEx(ImVec2 pix, ImAxis x_axis, ImAxis y_axis)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(::ImPlot::PixelsToPlot(reinterpret_cast<const ::ImVec2&>(pix), x_axis, y_axis));
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotPixelsToPlotFloat(float x, float y)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(::ImPlot::PixelsToPlot(x, y));
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotPixelsToPlotFloatEx(float x, float y, ImAxis x_axis, ImAxis y_axis)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(::ImPlot::PixelsToPlot(x, y, x_axis, y_axis));
}

CIMGUI_API ImVec2 cimgui::ImPlotPlotToPixels(cimgui::ImPlotPoint plt)
{
    return ::ImPlot::PlotToPixels(reinterpret_cast<const ::ImPlotPoint&>(plt));
}

CIMGUI_API ImVec2 cimgui::ImPlotPlotToPixelsEx(cimgui::ImPlotPoint plt, ImAxis x_axis, ImAxis y_axis)
{
    return ::ImPlot::PlotToPixels(reinterpret_cast<const ::ImPlotPoint&>(plt), x_axis, y_axis);
}

CIMGUI_API ImVec2 cimgui::ImPlotPlotToPixelsDouble(double x, double y)
{
    return ::ImPlot::PlotToPixels(x, y);
}

CIMGUI_API ImVec2 cimgui::ImPlotPlotToPixelsDoubleEx(double x, double y, ImAxis x_axis, ImAxis y_axis)
{
    return ::ImPlot::PlotToPixels(x, y, x_axis, y_axis);
}

CIMGUI_API ImVec2 cimgui::ImPlotGetPlotPos(void)
{
    return ::ImPlot::GetPlotPos();
}

CIMGUI_API ImVec2 cimgui::ImPlotGetPlotSize(void)
{
    return ::ImPlot::GetPlotSize();
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotGetPlotMousePos(void)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(::ImPlot::GetPlotMousePos());
}

CIMGUI_API cimgui::ImPlotPoint cimgui::ImPlotGetPlotMousePosEx(ImAxis x_axis, ImAxis y_axis)
{
    return reinterpret_cast<::cimgui::ImPlotPoint>(::ImPlot::GetPlotMousePos(x_axis, y_axis));
}

CIMGUI_API cimgui::ImPlotRect cimgui::ImPlotGetPlotLimits(void)
{
    return reinterpret_cast<::cimgui::ImPlotRect>(::ImPlot::GetPlotLimits());
}

CIMGUI_API cimgui::ImPlotRect cimgui::ImPlotGetPlotLimitsEx(ImAxis x_axis, ImAxis y_axis)
{
    return reinterpret_cast<::cimgui::ImPlotRect>(::ImPlot::GetPlotLimits(x_axis, y_axis));
}

CIMGUI_API bool cimgui::ImPlotIsPlotHovered(void)
{
    return ::ImPlot::IsPlotHovered();
}

CIMGUI_API bool cimgui::ImPlotIsAxisHovered(ImAxis axis)
{
    return ::ImPlot::IsAxisHovered(axis);
}

CIMGUI_API bool cimgui::ImPlotIsSubplotsHovered(void)
{
    return ::ImPlot::IsSubplotsHovered();
}

CIMGUI_API bool       cimgui::ImPlotIsPlotSelected(void)
{
    return ::ImPlot::IsPlotSelected();
}

CIMGUI_API cimgui::ImPlotRect cimgui::ImPlotGetPlotSelection(void)
{
    return reinterpret_cast<::cimgui::ImPlotRect>(::ImPlot::GetPlotSelection());
}

CIMGUI_API cimgui::ImPlotRect cimgui::ImPlotGetPlotSelectionEx(ImAxis x_axis, ImAxis y_axis)
{
    return reinterpret_cast<::cimgui::ImPlotRect>(::ImPlot::GetPlotSelection(x_axis, y_axis));
}

CIMGUI_API void       cimgui::ImPlotCancelPlotSelection(void)
{
    ::ImPlot::CancelPlotSelection();
}

CIMGUI_API void cimgui::ImPlotHideNextItem(void)
{
    ::ImPlot::HideNextItem();
}

CIMGUI_API void cimgui::ImPlotHideNextItemEx(bool hidden, ImPlotCond cond)
{
    ::ImPlot::HideNextItem(hidden, cond);
}

CIMGUI_API bool cimgui::ImPlotBeginAlignedPlots(const char* group_id)
{
    return ::ImPlot::BeginAlignedPlots(group_id);
}

CIMGUI_API bool cimgui::ImPlotBeginAlignedPlotsEx(const char* group_id, bool vertical)
{
    return ::ImPlot::BeginAlignedPlots(group_id, vertical);
}

CIMGUI_API void cimgui::ImPlotEndAlignedPlots(void)
{
    ::ImPlot::EndAlignedPlots();
}

CIMGUI_API bool cimgui::ImPlotBeginLegendPopup(const char* label_id)
{
    return ::ImPlot::BeginLegendPopup(label_id);
}

CIMGUI_API bool cimgui::ImPlotBeginLegendPopupEx(const char* label_id, ImGuiMouseButton mouse_button)
{
    return ::ImPlot::BeginLegendPopup(label_id, mouse_button);
}

CIMGUI_API void cimgui::ImPlotEndLegendPopup(void)
{
    ::ImPlot::EndLegendPopup();
}

CIMGUI_API bool cimgui::ImPlotIsLegendEntryHovered(const char* label_id)
{
    return ::ImPlot::IsLegendEntryHovered(label_id);
}

CIMGUI_API bool cimgui::ImPlotBeginDragDropTargetPlot(void)
{
    return ::ImPlot::BeginDragDropTargetPlot();
}

CIMGUI_API bool cimgui::ImPlotBeginDragDropTargetAxis(ImAxis axis)
{
    return ::ImPlot::BeginDragDropTargetAxis(axis);
}

CIMGUI_API bool cimgui::ImPlotBeginDragDropTargetLegend(void)
{
    return ::ImPlot::BeginDragDropTargetLegend();
}

CIMGUI_API void cimgui::ImPlotEndDragDropTarget(void)
{
    ::ImPlot::EndDragDropTarget();
}

CIMGUI_API bool cimgui::ImPlotBeginDragDropSourcePlot(ImGuiDragDropFlags flags)
{
    return ::ImPlot::BeginDragDropSourcePlot(flags);
}

CIMGUI_API bool cimgui::ImPlotBeginDragDropSourceAxis(ImAxis axis, ImGuiDragDropFlags flags)
{
    return ::ImPlot::BeginDragDropSourceAxis(axis, flags);
}

CIMGUI_API bool cimgui::ImPlotBeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags flags)
{
    return ::ImPlot::BeginDragDropSourceItem(label_id, flags);
}

CIMGUI_API void cimgui::ImPlotEndDragDropSource(void)
{
    ::ImPlot::EndDragDropSource();
}

CIMGUI_API cimgui::ImPlotStyle* cimgui::ImPlotGetStyle(void)
{
    return reinterpret_cast<::cimgui::ImPlotStyle*>(&::ImPlot::GetStyle());
}

CIMGUI_API void cimgui::ImPlotStyleColorsAuto(void)
{
    ::ImPlot::StyleColorsAuto();
}

CIMGUI_API void cimgui::ImPlotStyleColorsAutoEx(cimgui::ImPlotStyle* dst)
{
    ::ImPlot::StyleColorsAuto(reinterpret_cast<::ImPlotStyle*>(dst));
}

CIMGUI_API void cimgui::ImPlotStyleColorsClassic(void)
{
    ::ImPlot::StyleColorsClassic();
}

CIMGUI_API void cimgui::ImPlotStyleColorsClassicEx(cimgui::ImPlotStyle* dst)
{
    ::ImPlot::StyleColorsClassic(reinterpret_cast<::ImPlotStyle*>(dst));
}

CIMGUI_API void cimgui::ImPlotStyleColorsDark(void)
{
    ::ImPlot::StyleColorsDark();
}

CIMGUI_API void cimgui::ImPlotStyleColorsDarkEx(cimgui::ImPlotStyle* dst)
{
    ::ImPlot::StyleColorsDark(reinterpret_cast<::ImPlotStyle*>(dst));
}

CIMGUI_API void cimgui::ImPlotStyleColorsLight(void)
{
    ::ImPlot::StyleColorsLight();
}

CIMGUI_API void cimgui::ImPlotStyleColorsLightEx(cimgui::ImPlotStyle* dst)
{
    ::ImPlot::StyleColorsLight(reinterpret_cast<::ImPlotStyle*>(dst));
}

CIMGUI_API void cimgui::ImPlotPushStyleColor(ImPlotCol idx, ImU32 col)
{
    ::ImPlot::PushStyleColor(idx, col);
}

CIMGUI_API void cimgui::ImPlotPushStyleColorImVec4(ImPlotCol idx, ImVec4 col)
{
    ::ImPlot::PushStyleColor(idx, reinterpret_cast<const ::ImVec4&>(col));
}

CIMGUI_API void cimgui::ImPlotPopStyleColor(void)
{
    ::ImPlot::PopStyleColor();
}

CIMGUI_API void cimgui::ImPlotPopStyleColorEx(int count)
{
    ::ImPlot::PopStyleColor(count);
}

CIMGUI_API void cimgui::ImPlotPushStyleVar(ImPlotStyleVar idx, float val)
{
    ::ImPlot::PushStyleVar(idx, val);
}

CIMGUI_API void cimgui::ImPlotPushStyleVarInt(ImPlotStyleVar idx, int val)
{
    ::ImPlot::PushStyleVar(idx, val);
}

CIMGUI_API void cimgui::ImPlotPushStyleVarImVec2(ImPlotStyleVar idx, ImVec2 val)
{
    ::ImPlot::PushStyleVar(idx, reinterpret_cast<const ::ImVec2&>(val));
}

CIMGUI_API void cimgui::ImPlotPopStyleVar(void)
{
    ::ImPlot::PopStyleVar();
}

CIMGUI_API void cimgui::ImPlotPopStyleVarEx(int count)
{
    ::ImPlot::PopStyleVar(count);
}

CIMGUI_API void cimgui::ImPlotSetNextLineStyle(void)
{
    ::ImPlot::SetNextLineStyle();
}

CIMGUI_API void cimgui::ImPlotSetNextLineStyleEx(ImVec4 col, float weight)
{
    ::ImPlot::SetNextLineStyle(reinterpret_cast<const ::ImVec4&>(col), weight);
}

CIMGUI_API void cimgui::ImPlotSetNextFillStyle(void)
{
    ::ImPlot::SetNextFillStyle();
}

CIMGUI_API void cimgui::ImPlotSetNextFillStyleEx(ImVec4 col, float alpha_mod)
{
    ::ImPlot::SetNextFillStyle(reinterpret_cast<const ::ImVec4&>(col), alpha_mod);
}

CIMGUI_API void cimgui::ImPlotSetNextMarkerStyle(void)
{
    ::ImPlot::SetNextMarkerStyle();
}

CIMGUI_API void cimgui::ImPlotSetNextMarkerStyleEx(ImPlotMarker marker, float size, ImVec4 fill, float weight, ImVec4 outline)
{
    ::ImPlot::SetNextMarkerStyle(marker, size, reinterpret_cast<const ::ImVec4&>(fill), weight, reinterpret_cast<const ::ImVec4&>(outline));
}

CIMGUI_API void cimgui::ImPlotSetNextErrorBarStyle(void)
{
    ::ImPlot::SetNextErrorBarStyle();
}

CIMGUI_API void cimgui::ImPlotSetNextErrorBarStyleEx(ImVec4 col, float size, float weight)
{
    ::ImPlot::SetNextErrorBarStyle(reinterpret_cast<const ::ImVec4&>(col), size, weight);
}

CIMGUI_API ImVec4 cimgui::ImPlotGetLastItemColor(void)
{
    return ::ImPlot::GetLastItemColor();
}

CIMGUI_API const char* cimgui::ImPlotGetStyleColorName(ImPlotCol idx)
{
    return ::ImPlot::GetStyleColorName(idx);
}

CIMGUI_API const char* cimgui::ImPlotGetMarkerName(ImPlotMarker idx)
{
    return ::ImPlot::GetMarkerName(idx);
}

CIMGUI_API ImPlotColormap cimgui::ImPlotAddColormap(const char* name, const ImVec4* cols, int size)
{
    return ::ImPlot::AddColormap(name, cols, size);
}

CIMGUI_API ImPlotColormap cimgui::ImPlotAddColormapEx(const char* name, const ImVec4* cols, int size, bool qual)
{
    return ::ImPlot::AddColormap(name, cols, size, qual);
}

CIMGUI_API ImPlotColormap cimgui::ImPlotAddColormapImU32Ptr(const char* name, const ImU32* cols, int size)
{
    return ::ImPlot::AddColormap(name, cols, size);
}

CIMGUI_API ImPlotColormap cimgui::ImPlotAddColormapImU32PtrEx(const char* name, const ImU32* cols, int size, bool qual)
{
    return ::ImPlot::AddColormap(name, cols, size, qual);
}

CIMGUI_API int            cimgui::ImPlotGetColormapCount(void)
{
    return ::ImPlot::GetColormapCount();
}

CIMGUI_API const char*    cimgui::ImPlotGetColormapName(ImPlotColormap cmap)
{
    return ::ImPlot::GetColormapName(cmap);
}

CIMGUI_API ImPlotColormap cimgui::ImPlotGetColormapIndex(const char* name)
{
    return ::ImPlot::GetColormapIndex(name);
}

CIMGUI_API void cimgui::ImPlotPushColormap(ImPlotColormap cmap)
{
    ::ImPlot::PushColormap(cmap);
}

CIMGUI_API void cimgui::ImPlotPushColormapStr(const char* name)
{
    ::ImPlot::PushColormap(name);
}

CIMGUI_API void cimgui::ImPlotPopColormap(void)
{
    ::ImPlot::PopColormap();
}

CIMGUI_API void cimgui::ImPlotPopColormapEx(int count)
{
    ::ImPlot::PopColormap(count);
}

CIMGUI_API ImVec4 cimgui::ImPlotNextColormapColor(void)
{
    return ::ImPlot::NextColormapColor();
}

CIMGUI_API int    cimgui::ImPlotGetColormapSize(void)
{
    return ::ImPlot::GetColormapSize();
}

CIMGUI_API int    cimgui::ImPlotGetColormapSizeEx(ImPlotColormap cmap)
{
    return ::ImPlot::GetColormapSize(cmap);
}

CIMGUI_API ImVec4 cimgui::ImPlotGetColormapColor(int idx)
{
    return ::ImPlot::GetColormapColor(idx);
}

CIMGUI_API ImVec4 cimgui::ImPlotGetColormapColorEx(int idx, ImPlotColormap cmap)
{
    return ::ImPlot::GetColormapColor(idx, cmap);
}

CIMGUI_API ImVec4 cimgui::ImPlotSampleColormap(float t)
{
    return ::ImPlot::SampleColormap(t);
}

CIMGUI_API ImVec4 cimgui::ImPlotSampleColormapEx(float t, ImPlotColormap cmap)
{
    return ::ImPlot::SampleColormap(t, cmap);
}

CIMGUI_API void cimgui::ImPlotColormapScale(const char* label, double scale_min, double scale_max)
{
    ::ImPlot::ColormapScale(label, scale_min, scale_max);
}

CIMGUI_API void cimgui::ImPlotColormapScaleEx(const char* label, double scale_min, double scale_max, ImVec2 size, const char* format, ImPlotColormapScaleFlags flags, ImPlotColormap cmap)
{
    ::ImPlot::ColormapScale(label, scale_min, scale_max, reinterpret_cast<const ::ImVec2&>(size), format, flags, cmap);
}

CIMGUI_API bool cimgui::ImPlotColormapSlider(const char* label, float* t)
{
    return ::ImPlot::ColormapSlider(label, t);
}

CIMGUI_API bool cimgui::ImPlotColormapSliderEx(const char* label, float* t, ImVec4* out, const char* format, ImPlotColormap cmap)
{
    return ::ImPlot::ColormapSlider(label, t, out, format, cmap);
}

CIMGUI_API bool cimgui::ImPlotColormapButton(const char* label)
{
    return ::ImPlot::ColormapButton(label);
}

CIMGUI_API bool cimgui::ImPlotColormapButtonEx(const char* label, ImVec2 size, ImPlotColormap cmap)
{
    return ::ImPlot::ColormapButton(label, reinterpret_cast<const ::ImVec2&>(size), cmap);
}

CIMGUI_API void cimgui::ImPlotBustColorCache(void)
{
    ::ImPlot::BustColorCache();
}

CIMGUI_API void cimgui::ImPlotBustColorCacheEx(const char* plot_title_id)
{
    ::ImPlot::BustColorCache(plot_title_id);
}

CIMGUI_API cimgui::ImPlotInputMap* cimgui::ImPlotGetInputMap(void)
{
    return reinterpret_cast<::cimgui::ImPlotInputMap*>(&::ImPlot::GetInputMap());
}

CIMGUI_API void cimgui::ImPlotMapInputDefault(void)
{
    ::ImPlot::MapInputDefault();
}

CIMGUI_API void cimgui::ImPlotMapInputDefaultEx(cimgui::ImPlotInputMap* dst)
{
    ::ImPlot::MapInputDefault(reinterpret_cast<::ImPlotInputMap*>(dst));
}

CIMGUI_API void cimgui::ImPlotMapInputReverse(void)
{
    ::ImPlot::MapInputReverse();
}

CIMGUI_API void cimgui::ImPlotMapInputReverseEx(cimgui::ImPlotInputMap* dst)
{
    ::ImPlot::MapInputReverse(reinterpret_cast<::ImPlotInputMap*>(dst));
}

CIMGUI_API void cimgui::ImPlotItemIcon(ImVec4 col)
{
    ::ImPlot::ItemIcon(reinterpret_cast<const ::ImVec4&>(col));
}

CIMGUI_API void cimgui::ImPlotItemIconImU32(ImU32 col)
{
    ::ImPlot::ItemIcon(col);
}

CIMGUI_API void cimgui::ImPlotColormapIcon(ImPlotColormap cmap)
{
    ::ImPlot::ColormapIcon(cmap);
}

CIMGUI_API ImDrawList* cimgui::ImPlotGetPlotDrawList(void)
{
    return ::ImPlot::GetPlotDrawList();
}

CIMGUI_API void        cimgui::ImPlotPushPlotClipRect(void)
{
    ::ImPlot::PushPlotClipRect();
}

CIMGUI_API void        cimgui::ImPlotPushPlotClipRectEx(float expand)
{
    ::ImPlot::PushPlotClipRect(expand);
}

CIMGUI_API void        cimgui::ImPlotPopPlotClipRect(void)
{
    ::ImPlot::PopPlotClipRect();
}

CIMGUI_API bool cimgui::ImPlotShowStyleSelector(const char* label)
{
    return ::ImPlot::ShowStyleSelector(label);
}

CIMGUI_API bool cimgui::ImPlotShowColormapSelector(const char* label)
{
    return ::ImPlot::ShowColormapSelector(label);
}

CIMGUI_API bool cimgui::ImPlotShowInputMapSelector(const char* label)
{
    return ::ImPlot::ShowInputMapSelector(label);
}

CIMGUI_API void cimgui::ImPlotShowStyleEditor(void)
{
    ::ImPlot::ShowStyleEditor();
}

CIMGUI_API void cimgui::ImPlotShowStyleEditorEx(cimgui::ImPlotStyle* ref)
{
    ::ImPlot::ShowStyleEditor(reinterpret_cast<::ImPlotStyle*>(ref));
}

CIMGUI_API void cimgui::ImPlotShowUserGuide(void)
{
    ::ImPlot::ShowUserGuide();
}

CIMGUI_API void cimgui::ImPlotShowMetricsWindow(void)
{
    ::ImPlot::ShowMetricsWindow();
}

CIMGUI_API void cimgui::ImPlotShowMetricsWindowEx(bool* p_popen)
{
    ::ImPlot::ShowMetricsWindow(p_popen);
}

CIMGUI_API void cimgui::ImPlotShowDemoWindow(void)
{
    ::ImPlot::ShowDemoWindow();
}

CIMGUI_API void cimgui::ImPlotShowDemoWindowEx(bool* p_open)
{
    ::ImPlot::ShowDemoWindow(p_open);
}
