ffi.hpp

Go to the documentation of this file.

#pragma once
 
// Warning, this file is autogenerated by cbindgen. Don't modify this manually.
 
#include <cstdarg>
#include <cstdint>
#include <cstdlib>
#include <ostream>
#include <new>
 
namespace openpine {
namespace ffi {

constexpr static const uint32_t DISPLAY_ALL = 65535;

constexpr static const uint32_t DISPLAY_NONE = 0;

constexpr static const uint32_t DISPLAY_DATA_WINDOW = 1;

constexpr static const uint32_t DISPLAY_PANE = 2;

constexpr static const uint32_t DISPLAY_PINE_SCREENER = 4;

constexpr static const uint32_t DISPLAY_PRICE_SCALE = 8;

constexpr static const uint32_t DISPLAY_STATUS_LINE = 16;

enum class OutputMode {
  Chart = 0,
  Stream = 1,
};

enum class EventKind {
  Log = 0,
  Alert = 1,
  BarStart = 2,
  BarEnd = 3,
  HistoryEnd = 4,
  DrawAddPlot = 5,
  DrawUpdatePlot = 6,
};

enum class ScriptTypeKind {
  Indicator = 0,
  Library = 1,
  Strategy = 2,
};

enum class Format : int32_t {
  Inherit = 0,
  Price = 1,
  Volume = 2,
  Percent = 3,
  MinTick = 4,
};

enum class ScaleType : int32_t {
  None = 0,
  Left = 1,
  Right = 2,
};

enum class QuantityType : int32_t {
  Fixed = 0,
  Cash = 1,
  PercentOfEquity = 2,
};

enum class CommissionType : int32_t {
  Percent = 0,
  CashPerContract = 1,
  CashPerOrder = 2,
};

enum class CloseEntriesRule : int32_t {
  FIFO = 0,
  ANY = 1,
};

enum class TimeUnit {
  Second = 0,
  Minute = 1,
  Day = 2,
  Week = 3,
  Month = 4,
  Tick = 5,
};

enum class SourceType : int64_t {
  Open = 0,
  High = 1,
  Low = 2,
  Close = 3,
  Hl2 = 4,
  Hlc3 = 5,
  Ohlc4 = 6,
  Hlcc4 = 7,
};

enum class TradeSession {
  PreMarket,
  Regular,
  AfterHours,
  Overnight,
};

enum class GraphType {
  Hline,
  Label,
  Line,
  LineFill,
  Box,
  Polyline,
  Table,
};

enum class HlineStyle {
  Solid = 0,
  Dashed = 1,
  Dotted = 2,
};

enum class XLocation {
  Index,
  Time,
};

enum class Extend {
  None,
  Left,
  Right,
  Both,
};

enum class LineStyle {
  Solid,
  Dotted,
  Dashed,
  ArrowLeft,
  ArrowRight,
  ArrowBoth,
};

enum class HorizontalAlign {
  Left,
  Center,
  Right,
};

enum class VerticalAlign {
  Top,
  Middle,
  Bottom,
};

enum class TextWrap {
  Auto,
  None,
};

enum class FontFamily {
  Default,
  Monospace,
};

enum class TextFormatting {
  None,
  Bold,
  Italic,
};

enum class TablePosition {
  TopLeft,
  TopRight,
  TopCenter,
  BottomLeft,
  BottomRight,
  BottomCenter,
  MiddleLeft,
  MiddleRight,
  MiddleCenter,
};

enum class YLocation {
  Price,
  AboveBar,
  BelowBar,
};

enum class LabelStyle {
  None,
  ArrowDown,
  ArrowUp,
  Circle,
  Cross,
  Diamond,
  Flag,
  LabelCenter,
  LabelDown,
  LabelLeft,
  LabelLowerLeft,
  LabelLowerRight,
  LabelRight,
  LabelUp,
  LabelUpperLeft,
  LabelUpperRight,
  Square,
  TextOutline,
  TriangleDown,
  TriangleUp,
  XCross,
};

enum class SeriesGraphType {
  Plot,
  BackgroundColors,
  Fill,
  PlotArrow,
  PlotBar,
  PlotCandle,
  PlotChar,
  PlotShape,
};

enum class FillAnchorType {
  Plot,
  Hline,
};

enum class FillColorType {
  Solid,
  Gradient,
};

enum class Location {
  AboveBar = 0,
  BelowBar = 1,
  Absolute = 2,
  Top = 3,
  Bottom = 4,
};

enum class Size {
  Auto = 0,
  Tiny = 1,
  Small = 2,
  Normal = 3,
  Large = 4,
  Huge = 5,
};

enum class Shape {
  ArrowDown = 0,
  ArrowUp = 1,
  Circle = 2,
  Cross = 3,
  Diamond = 4,
  Flag = 5,
  LabelDown = 6,
  LabelUp = 7,
  Square = 8,
  TriangleDown = 9,
  TriangleUp = 10,
  XCross = 11,
};

enum class PlotStyle {
  Line = 0,
  LineBr = 1,
  Area = 2,
  AreaBr = 3,
  Circles = 4,
  Columns = 5,
  Cross = 6,
  Histogram = 7,
  StepLine = 8,
  Diamond = 9,
  StepLineBr = 10,
};

enum class PlotLineStyle {
  Solid = 0,
  Dashed = 1,
  Dotted = 2,
};

struct Result;

struct BackgroundColors;

struct BarColors;

struct Box;

struct CandlestickStream;

struct Chart;

struct Fill;

struct FilledOrdersIterator;

struct Graph;

struct CGraphIterator;

struct Hline;

struct Input;

struct Instance;

struct Label;

struct Line;

struct LineFill;

struct Plot;

struct PlotArrow;

struct PlotBar;

struct PlotCandle;

struct PlotChar;

struct PlotShape;

struct Polyline;

struct ScriptInfo;

struct SeriesGraph;

struct CSeriesGraphIterator;

struct Table;

struct TableCell;
 
template<typename T = void>
struct Option;

struct Position {
  uint32_t column;
  uint32_t line;
  uint32_t byte_offset;
};

struct Span {
  Position start;
  Position end;
};

struct PineStringRef {
  const uint8_t *data;
  uintptr_t len;
};

struct LastInfo {
  uintptr_t index;
  int64_t time;
};

struct PartialSymbolInfo {
  const char *currency;
  int32_t min_move;
  int32_t price_scale;
};

struct DataProvider {
  void *context;
  const char *(*symbol_info_fn)(void *context,
                                const uint8_t *symbol,
                                uintptr_t symbol_len,
                                PartialSymbolInfo *out);
  CandlestickStream *(*candlesticks_open_fn)(void *context,
                                             const uint8_t *symbol,
                                             uintptr_t symbol_len,
                                             const uint8_t *timeframe,
                                             uintptr_t timeframe_len,
                                             int64_t from_time);
};

struct CreateInstanceOptions {
  PineStringRef source;
  const PineStringRef *path;
  PineStringRef timeframe;
  PineStringRef symbol;
  const uint32_t *background_color;
  const LastInfo *last_info;
  const DataProvider *data_provider;
  OutputMode output_mode;
};

struct BarStartEvent {
  uintptr_t bar_index;
  int64_t timestamp;
  int32_t bar_state;
};

struct DrawUpdatePlot {
  int64_t id;
  uintptr_t bar_index;
  int64_t timestamp;
  double value;
};

struct DrawAddPlot {
  int64_t id;
  const uint8_t *title;
  uintptr_t title_len;
};

struct Event {
  EventKind kind;
  BarStartEvent bar_start;
  DrawUpdatePlot draw_update_plot;
  DrawAddPlot draw_add_plot;
};

using InstanceEventCallback = void(*)(const Event *event, void *user_data);

using InstanceRunCallback = void(*)(const Result *result, void *user_data);
 
struct Indicator {
  PineStringRef title;
  bool has_short_title;
  PineStringRef short_title;
  bool overlay;
  Format format;
  bool has_precision;
  uint8_t precision;
  ScaleType scale;
  bool has_max_bars_back;
  uintptr_t max_bars_back;
  bool has_timeframe;
  PineStringRef timeframe;
  bool timeframe_gaps;
  bool explicit_plot_zorder;
  uintptr_t max_lines_count;
  uintptr_t max_labels_count;
  uintptr_t max_boxes_count;
  bool has_calc_bars_count;
  uintptr_t calc_bars_count;
  uintptr_t max_polylines_count;
  bool dynamic_requests;
  bool behind_chart;
};
 
struct Library {
  PineStringRef title;
  bool overlay;
  bool dynamic_requests;
};
 
struct Strategy {
  PineStringRef title;
  bool has_short_title;
  PineStringRef short_title;
  bool overlay;
  Format format;
  bool has_precision;
  uint8_t precision;
  ScaleType scale;
  uint32_t pyramiding;
  bool calc_on_order_fills;
  bool calc_on_every_tick;
  bool has_max_bars_back;
  uintptr_t max_bars_back;
  uint32_t backtest_fill_limits_assumption;
  QuantityType default_qty_type;
  double default_qty_value;
  double initial_capital;
  PineStringRef currency_code;
  uint32_t slippage;
  CommissionType commission_type;
  double commission_value;
  bool process_orders_on_close;
  CloseEntriesRule close_entries_rule;
  double margin_long;
  double margin_short;
  bool explicit_plot_zorder;
  uintptr_t max_lines_count;
  uintptr_t max_labels_count;
  uintptr_t max_boxes_count;
  bool has_calc_bars_count;
  uintptr_t calc_bars_count;
  double risk_free_rate;
  bool use_bar_magnifier;
  bool fill_orders_on_standard_ohlc;
  uintptr_t max_polylines_count;
  bool dynamic_requests;
  bool behind_chart;
};
 
struct InputInt {
  int64_t id;
  int64_t default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  uintptr_t options_length;
  bool has_min_value;
  int64_t min_value;
  bool has_max_value;
  int64_t max_value;
  bool has_step;
  int64_t step;
  bool confirm;
};
 
struct InputFloat {
  int64_t id;
  double default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  bool has_options;
  uintptr_t options_length;
  bool has_min_value;
  double min_value;
  bool has_max_value;
  double max_value;
  bool has_step;
  double step;
  bool confirm;
};
 
struct InputBool {
  int64_t id;
  bool default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  bool confirm;
};
 
struct InputColor {
  int64_t id;
  uint32_t default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  bool confirm;
};
 
struct InputString {
  int64_t id;
  PineStringRef default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  uintptr_t options_length;
  bool confirm;
};
 
struct InputPrice {
  int64_t id;
  double default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  bool confirm;
};
 
struct InputSymbol {
  int64_t id;
  PineStringRef default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  bool confirm;
};

struct TimeFrame {
  uint32_t quantity;
  TimeUnit unit;
};
 
struct InputTimeFrame {
  int64_t id;
  bool is_chart_default;
  TimeFrame default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  uintptr_t options_length;
  bool confirm;
};
 
struct InputSource {
  int64_t id;
  SourceType default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  bool confirm;
};
 
struct InputEnum {
  int64_t id;
  uintptr_t enum_typeid;
  int64_t default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  uintptr_t options_length;
  bool confirm;
};
 
struct InputSession {
  int64_t id;
  PineStringRef default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  uintptr_t options_length;
  bool confirm;
};
 
struct InputTime {
  int64_t id;
  int64_t default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_inline;
  PineStringRef inline_;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  bool confirm;
};
 
struct InputTextArea {
  int64_t id;
  PineStringRef default_value;
  bool has_title;
  PineStringRef title;
  bool has_tooltip;
  PineStringRef tooltip;
  bool has_group;
  PineStringRef group;
  uint64_t display;
  bool active;
  bool confirm;
};
 
struct InputEnumOption {
  int64_t value;
  PineStringRef title;
};

struct Candlestick {
  int64_t time;
  double open;
  double high;
  double low;
  double close;
  double volume;
  double turnover;
  TradeSession trade_session;
};

struct CandlestickItem {
  Candlestick candlestick;
  bool confirmed;
};

struct FilledOrder {
  PineStringRef order_id;
  double price;
  double quantity;
};

struct PolylinePoint {
  int64_t x;
  double y;
};

struct FillGradient {
  double top_value;
  double bottom_value;
  uint32_t color1;
  uint32_t color2;
};

struct Bar {
  double open;
  double high;
  double low;
  double close;
};
 
extern "C" {

bool resultIsSuccess(const Result *result);

const char *resultErrorMessage(const Result *result);

const Span *resultErrorSpan(const Result *result);

void resultDelete(Result *result);

Result *instanceCreate(const CreateInstanceOptions *options, Instance **instance);

Result *instanceRun(Instance *instance,
                    const uint8_t *symbol,
                    uintptr_t symbol_len,
                    const uint8_t *timeframe,
                    uintptr_t timeframe_len,
                    int64_t from_time,
                    Option<InstanceEventCallback> event_callback,
                    InstanceRunCallback callback,
                    void *user_data);

void instanceDelete(Instance *instance);
 
const ScriptInfo *instanceScriptInfo(const Instance *instance);
 
bool scriptInfoOverlay(const ScriptInfo *script_info);
 
ScriptTypeKind scriptInfoScriptType(const ScriptInfo *script_info);
 
bool scriptInfoTitle(const ScriptInfo *script_info, PineStringRef *value);
 
bool scriptInfoIndicator(const ScriptInfo *script_info, Indicator *out);
 
bool scriptInfoLibrary(const ScriptInfo *script_info, Library *out);
 
bool scriptInfoStrategy(const ScriptInfo *script_info, Strategy *out);
 
uintptr_t scriptInfoInputsLength(const ScriptInfo *script_info);
 
const Input *scriptInfoInput(const ScriptInfo *script_info, uintptr_t index);
 
bool inputFillInt(const Input *input, InputInt *out);
 
bool inputFillFloat(const Input *input, InputFloat *out);
 
bool inputFillBool(const Input *input, InputBool *out);
 
bool inputFillColor(const Input *input, InputColor *out);
 
bool inputFillString(const Input *input, InputString *out);
 
bool inputFillPrice(const Input *input, InputPrice *out);
 
bool inputFillSymbol(const Input *input, InputSymbol *out);
 
bool inputFillTimeFrame(const Input *input, InputTimeFrame *out);
 
bool inputFillSource(const Input *input, InputSource *out);
 
bool inputFillEnum(const Input *input, InputEnum *out);
 
bool inputFillSession(const Input *input, InputSession *out);
 
bool inputFillTime(const Input *input, InputTime *out);
 
bool inputFillTextArea(const Input *input, InputTextArea *out);
 
bool inputIntOptionAt(const Input *input, uintptr_t index, int64_t *out);
 
bool inputFloatOptionAt(const Input *input, uintptr_t index, double *out);
 
bool inputStringOptionAt(const Input *input, uintptr_t index, PineStringRef *value);
 
bool inputTimeFrameOptionAt(const Input *input, uintptr_t index, PineStringRef *value);
 
bool inputEnumOptionAt(const Input *input, uintptr_t index, InputEnumOption *out);
 
bool inputSessionOptionAt(const Input *input, uintptr_t index, PineStringRef *value);
 
uintptr_t scriptInfoAlertConditionsLength(const ScriptInfo *script_info);
 
bool scriptInfoAlertConditionTitle(const ScriptInfo *script_info,
                                   uintptr_t index,
                                   PineStringRef *value);
 
bool scriptInfoAlertConditionMessage(const ScriptInfo *script_info,
                                     uintptr_t index,
                                     PineStringRef *value);

CandlestickStream *candlestickStreamCreate(const uint8_t *_symbol,
                                           uintptr_t _symbol_len,
                                           const uint8_t *_timeframe,
                                           uintptr_t _timeframe_len,
                                           int64_t _from_time);

Result *candlestickStreamPush(CandlestickStream *stream, const CandlestickItem *item);

Result *candlestickStreamFinish(CandlestickStream *stream);

const Chart *instanceChart(const Instance *instance);

uintptr_t chartSeriesLength(const Chart *chart);

FilledOrdersIterator *chartFilledOrdersOnBar(const Chart *chart, uintptr_t bar_index);

bool filledOrdersIteratorNext(FilledOrdersIterator *iter, FilledOrder *out);

void filledOrdersIteratorDelete(FilledOrdersIterator *iter);

CGraphIterator *chartGraphIterator(const Chart *chart);

bool graphIteratorNext(CGraphIterator *iter, int64_t *id, const Graph **graph);

void graphIteratorDelete(CGraphIterator *iter);

GraphType graphType(const Graph *g);

const Hline *graphHline(const Graph *g);

const Label *graphLabel(const Graph *g);

const Line *graphLine(const Graph *g);

const LineFill *graphLineFill(const Graph *g);

const Polyline *graphPolyline(const Graph *g);

const Table *graphTable(const Graph *g);

const Box *graphBox(const Graph *g);

double hlineValue(const Hline *h);

bool hlineColor(const Hline *h, uint32_t *color);

bool hlineTitle(const Hline *h, PineStringRef *value);

HlineStyle hlineLineStyle(const Hline *h);

int32_t hlineLineWidth(const Hline *h);

bool hlineEditable(const Hline *h);

uint32_t hlineDisplay(const Hline *h);

int64_t lineX1(const Line *l);

double lineY1(const Line *l);

int64_t lineX2(const Line *l);

double lineY2(const Line *l);

XLocation lineXloc(const Line *l);

Extend lineExtend(const Line *l);

bool lineColor(const Line *l, uint32_t *color);

LineStyle lineStyle(const Line *l);

int32_t lineWidth(const Line *l);

bool lineForceOverlay(const Line *l);

int64_t lineFillLine1Id(const LineFill *lf);

int64_t lineFillLine2Id(const LineFill *lf);

bool lineFillColor(const LineFill *lf, uint32_t *color);

uintptr_t polylinePointsLength(const Polyline *p);

bool polylinePoint(const Polyline *p, uintptr_t idx, PolylinePoint *out);

bool polylineCurved(const Polyline *p);

bool polylineClosed(const Polyline *p);

bool polylineLineColor(const Polyline *p, uint32_t *color);

bool polylineFillColor(const Polyline *p, uint32_t *color);

LineStyle polylineLineStyle(const Polyline *p);

int32_t polylineLineWidth(const Polyline *p);

bool polylineForceOverlay(const Polyline *p);

int64_t boxLeft(const Box *b);

double boxTop(const Box *b);

int64_t boxRight(const Box *b);

double boxBottom(const Box *b);

bool boxBorderColor(const Box *b, uint32_t *color);

int32_t boxBorderWidth(const Box *b);

LineStyle boxBorderStyle(const Box *b);

Extend boxExtend(const Box *b);

XLocation boxXloc(const Box *b);

bool boxBackgroundColor(const Box *b, uint32_t *color);

void boxText(const Box *b, PineStringRef *value);

uint32_t boxTextSize(const Box *b);

bool boxTextColor(const Box *b, uint32_t *color);

HorizontalAlign boxTextHalign(const Box *b);

VerticalAlign boxTextValign(const Box *b);

TextWrap boxTextWrap(const Box *b);

FontFamily boxTextFontFamily(const Box *b);

TextFormatting boxTextFormatting(const Box *b);

bool boxForceOverlay(const Box *b);

TablePosition tablePosition(const Table *t);

uintptr_t tableNumColumns(const Table *t);

uintptr_t tableNumRows(const Table *t);

bool tableBackgroundColor(const Table *t, uint32_t *color);

bool tableFrameColor(const Table *t, uint32_t *color);

int32_t tableFrameWidth(const Table *t);

bool tableBorderColor(const Table *t, uint32_t *color);

int32_t tableBorderWidth(const Table *t);

bool tableForceOverlay(const Table *t);

const TableCell *tableCell(const Table *t, uintptr_t row, uintptr_t col);

void tableCellText(const TableCell *c, PineStringRef *value);

float tableCellWidth(const TableCell *c);

float tableCellHeight(const TableCell *c);

bool tableCellTextColor(const TableCell *c, uint32_t *color);

HorizontalAlign tableCellTextHalign(const TableCell *c);

VerticalAlign tableCellTextValign(const TableCell *c);

uint32_t tableCellTextSize(const TableCell *c);

bool tableCellBackgroundColor(const TableCell *c, uint32_t *color);

bool tableCellTooltip(const TableCell *c, PineStringRef *value);

FontFamily tableCellTextFontFamily(const TableCell *c);

TextFormatting tableCellTextFormatting(const TableCell *c);

uintptr_t tableCellColspan(const TableCell *c);

uintptr_t tableCellRowspan(const TableCell *c);

int64_t labelX(const Label *label);

double labelY(const Label *label);

void labelText(const Label *label, PineStringRef *value);

XLocation labelXloc(const Label *label);

YLocation labelYloc(const Label *label);

bool labelColor(const Label *label, uint32_t *color);

LabelStyle labelStyle(const Label *label);

bool labelTextColor(const Label *label, uint32_t *color);

uint32_t labelSize(const Label *label);

HorizontalAlign labelTextAlign(const Label *label);

bool labelTooltip(const Label *label, PineStringRef *value);

FontFamily labelTextFontFamily(const Label *label);

bool labelForceOverlay(const Label *label);

TextFormatting labelTextFormatting(const Label *label);

CSeriesGraphIterator *chartSeriesGraphIterator(const Chart *chart);

bool seriesGraphIteratorNext(CSeriesGraphIterator *iter,
                             int64_t *id,
                             const SeriesGraph **series_graph);

void seriesGraphIteratorDelete(CSeriesGraphIterator *iter);

SeriesGraphType seriesGraphType(const SeriesGraph *sg);

const Plot *seriesGraphPlot(const SeriesGraph *sg);

const BackgroundColors *seriesGraphBackgroundColors(const SeriesGraph *sg);

int32_t bgcolorsOffset(const BackgroundColors *bgcolors);

bool bgcolorsEditable(const BackgroundColors *bgcolors);

bool bgcolorsShowLast(const BackgroundColors *bgcolors, uintptr_t *value);

bool bgcolorsTitle(const BackgroundColors *bgcolors, PineStringRef *value);

uint32_t bgcolorsDisplay(const BackgroundColors *bgcolors);

bool bgcolorsForceOverlay(const BackgroundColors *bgcolors);

bool bgcolorsColor(const BackgroundColors *bgcolors, uintptr_t idx, uint32_t *color);

const Fill *seriesGraphFill(const SeriesGraph *sg);

FillAnchorType fillFromType(const Fill *fill);

bool fillFromPlotId(const Fill *fill, int64_t *value);

bool fillFromHlineId(const Fill *fill, int64_t *value);

FillAnchorType fillToType(const Fill *fill);

bool fillToPlotId(const Fill *fill, int64_t *value);

bool fillToHlineId(const Fill *fill, int64_t *value);

bool fillTitle(const Fill *fill, PineStringRef *value);

bool fillEditable(const Fill *fill);

bool fillShowLast(const Fill *fill, uintptr_t *value);

bool fillFillGaps(const Fill *fill);

uint32_t fillDisplay(const Fill *fill);

bool fillColorType(const Fill *fill, uintptr_t idx, FillColorType *value);

bool fillColorSolid(const Fill *fill, uintptr_t idx, uint32_t *value);

bool fillColorGradient(const Fill *fill, uintptr_t idx, FillGradient *value);

const PlotArrow *seriesGraphPlotArrow(const SeriesGraph *sg);

bool plotArrowTitle(const PlotArrow *plot, PineStringRef *value);

bool plotArrowValue(const PlotArrow *plot, uintptr_t idx, double *value);

bool plotArrowUpColor(const PlotArrow *plot, uintptr_t idx, uint32_t *color);

bool plotArrowDownColor(const PlotArrow *plot, uintptr_t idx, uint32_t *color);

int32_t plotArrowOffset(const PlotArrow *plot);

uintptr_t plotArrowMinHeight(const PlotArrow *plot);

uintptr_t plotArrowMaxHeight(const PlotArrow *plot);

bool plotArrowEditable(const PlotArrow *plot);

bool plotArrowShowLast(const PlotArrow *plot, uintptr_t *value);

uint32_t plotArrowDisplay(const PlotArrow *plot);

bool plotArrowFormat(const PlotArrow *plot, PineStringRef *value);

bool plotArrowPrecision(const PlotArrow *plot, int32_t *value);

bool plotArrowForceOverlay(const PlotArrow *plot);

const PlotBar *seriesGraphPlotBar(const SeriesGraph *sg);

bool plotBarTitle(const PlotBar *plot, PineStringRef *value);

bool plotBarValue(const PlotBar *plot, uintptr_t idx, Bar *value);

bool plotBarColor(const PlotBar *plot, uintptr_t idx, uint32_t *color);

bool plotBarEditable(const PlotBar *plot);

bool plotBarShowLast(const PlotBar *plot, uintptr_t *value);

uint32_t plotBarDisplay(const PlotBar *plot);

bool plotBarFormat(const PlotBar *plot, PineStringRef *value);

bool plotBarPrecision(const PlotBar *plot, int32_t *value);

bool plotBarForceOverlay(const PlotBar *plot);

const PlotCandle *seriesGraphPlotCandle(const SeriesGraph *sg);

bool plotCandleTitle(const PlotCandle *plot, PineStringRef *value);

bool plotCandleValue(const PlotCandle *plot, uintptr_t idx, Bar *value);

bool plotCandleColor(const PlotCandle *plot, uintptr_t idx, uint32_t *color);

bool plotCandleWickColor(const PlotCandle *plot, uintptr_t idx, uint32_t *color);

bool plotCandleBorderColor(const PlotCandle *plot, uintptr_t idx, uint32_t *color);

bool plotCandleEditable(const PlotCandle *plot);

bool plotCandleShowLast(const PlotCandle *plot, uintptr_t *value);

uint32_t plotCandleDisplay(const PlotCandle *plot);

bool plotCandleFormat(const PlotCandle *plot, PineStringRef *value);

bool plotCandlePrecision(const PlotCandle *plot, int32_t *value);

bool plotCandleForceOverlay(const PlotCandle *plot);

const PlotChar *seriesGraphPlotChar(const SeriesGraph *sg);

bool plotCharTitle(const PlotChar *plot, PineStringRef *value);

bool plotCharValue(const PlotChar *plot, uintptr_t idx, double *value);

bool plotCharBoolValue(const PlotChar *plot, uintptr_t idx, bool *value);

uint32_t plotCharChar(const PlotChar *plot);

Location plotCharLocation(const PlotChar *plot);

bool plotCharColor(const PlotChar *plot, uintptr_t idx, uint32_t *color);

int32_t plotCharOffset(const PlotChar *plot);

bool plotCharText(const PlotChar *plot, PineStringRef *value);

bool plotCharTextColor(const PlotChar *plot, uintptr_t idx, uint32_t *color);

bool plotCharEditable(const PlotChar *plot);

Size plotCharSize(const PlotChar *plot);

bool plotCharShowLast(const PlotChar *plot, uintptr_t *value);

uint32_t plotCharDisplay(const PlotChar *plot);

bool plotCharFormat(const PlotChar *plot, PineStringRef *value);

bool plotCharPrecision(const PlotChar *plot, int32_t *value);

bool plotCharForceOverlay(const PlotChar *plot);

const PlotShape *seriesGraphPlotShape(const SeriesGraph *sg);

bool plotShapeTitle(const PlotShape *plot, PineStringRef *value);

bool plotShapeValue(const PlotShape *plot, uintptr_t idx, double *value);

bool plotShapeBoolValue(const PlotShape *plot, uintptr_t idx, bool *value);

Shape plotShapeStyle(const PlotShape *plot);

Location plotShapeLocation(const PlotShape *plot);

bool plotShapeColor(const PlotShape *plot, uintptr_t idx, uint32_t *color);

int32_t plotShapeOffset(const PlotShape *plot);

bool plotShapeText(const PlotShape *plot, PineStringRef *value);

bool plotShapeTextColor(const PlotShape *plot, uintptr_t idx, uint32_t *color);

bool plotShapeEditable(const PlotShape *plot);

Size plotShapeSize(const PlotShape *plot);

bool plotShapeShowLast(const PlotShape *plot, uintptr_t *value);

uint32_t plotShapeDisplay(const PlotShape *plot);

bool plotShapeFormat(const PlotShape *plot, PineStringRef *value);

bool plotShapePrecision(const PlotShape *plot, int32_t *value);

bool plotShapeForceOverlay(const PlotShape *plot);

bool plotTitle(const Plot *plot, PineStringRef *value);

bool plotValue(const Plot *plot, uintptr_t idx, double *value);

bool plotColor(const Plot *plot, uintptr_t idx, uint32_t *color);

int32_t plotLineWidth(const Plot *plot);

PlotStyle plotStyle(const Plot *plot);

bool plotTrackPrice(const Plot *plot);

double plotHistBase(const Plot *plot);

int32_t plotOffset(const Plot *plot);

bool plotJoin(const Plot *plot);

bool plotEditable(const Plot *plot);

bool plotShowLast(const Plot *plot, uintptr_t *value);

uint32_t plotDisplay(const Plot *plot);

bool plotFormat(const Plot *plot, PineStringRef *value);

bool plotPrecision(const Plot *plot, int32_t *value);

bool plotForceOverlay(const Plot *plot);

PlotLineStyle plotLineStyle(const Plot *plot);

const BarColors *chartBarColors(const Chart *chart);

int32_t barcolorsOffset(const BarColors *barcolors);

bool barcolorsEditable(const BarColors *barcolors);

bool barcolorsShowLast(const BarColors *barcolors, uintptr_t *value);

bool barcolorsTitle(const BarColors *barcolors, PineStringRef *value);

uint32_t barcolorsDisplay(const BarColors *barcolors);

bool barcolorsColor(const BarColors *barcolors, uintptr_t idx, uint32_t *color);
 
}  // extern "C"
 
}  // namespace ffi
}  // namespace openpine