defmodule ElixirLibxl do
	@moduledoc """
	# [LibXL](https://www.libxl.com/) elixir port

	このモジュールを使用するにはLibXLのC言語ライブラリがインストールされていることが必須です。

	* 必須ヘッダ

	/usr/local/include または /usr/include

	/usr/local/include/AutoFilterA.h または /usr/include/AutoFilterA.h

	/usr/local/include/AutoFilterW.h または /usr/include/AutoFilterW.h

	/usr/local/include/BookA.h または /usr/include/BookA.h

	/usr/local/include/BookW.h または /usr/include/BookW.h

	/usr/local/include/FilterColumnA.h または /usr/include/FilterColumnA.h

	/usr/local/include/FilterColumnW.h または /usr/include/FilterColumnW.h

	/usr/local/include/FontA.h または /usr/include/FontA.h

	/usr/local/include/FontW.h または /usr/include/FontW.h

	/usr/local/include/FormControlA.h または /usr/include/FormControlA.h

	/usr/local/include/FormControlW.h または /usr/include/FormControlW.h

	/usr/local/include/FormatA.h または /usr/include/FormatA.h

	/usr/local/include/FormatW.h または /usr/include/FormatW.h

	/usr/local/include/RichStringA.h または /usr/include/RichStringA.h

	/usr/local/include/RichStringW.h または /usr/include/RichStringW.h

	/usr/local/include/SheetA.h または /usr/include/SheetA.h

	/usr/local/include/SheetW.h または /usr/include/SheetW.h

	/usr/local/include/enum.h または /usr/include/enum.h

	/usr/local/include/handle.h または /usr/include/handle.h

	/usr/local/include/libxl.h または /usr/include/libxl.h

	/usr/local/include/setup.h または /usr/include/setup.h

	* 必須ライブラリ

	/usr/local/lib/libxl.a または /usr/lib/libxl.a

	/usr/local/lib/libxl.dylib または /usr/lib/libxl.dylib

	/usr/local/lib/libxl.so または /usr/lib/libxl.so

	# install

	```elixir
	def deps do
	[
		{:elixir_libxl, "~> 0.2.0"}
	]
	end
	```

	# 基本的な使用方法

	```elixir
	book_handle = ElixirLibxl.xlCreateXMLBook()

	ElixirLibxl.xlBookLoad(book_handle, "path/to/xlsx")

	ElixirLibxl.xlBookRelease(book_handle)
	```

	# 注意点

	* 定数はConstant.exに定義してありますが実際にコンパイルされた値ではないので注意してください。

	* 出力用のポインタ引数の存在する関数は引数には含まずListとして、関数の戻り値と共にreturnされます。

		- 例

		`xlSheetMerge()`のC言語プロトタイプは`int xlSheetMerge(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast);`

		となっていますが本モジュールでは`@spec xlSheetMerge(reference(), integer()) :: [integer()]`となります。


	# revision

	version: "0.2.0" libxl 4.1.0

	"""
	@on_load {:load_nif, 0}

	@compile {:autoload, false}

	def load_nif do
		Application.app_dir(:elixir_libxl, "priv/libxl")
		|> to_charlist()
		|> :erlang.load_nif(0)
	end

	# ========================================================================================================================================================

	# int xlAutoFilterGetRef(AutoFilterHandle handle, int* rowFirst, int* rowLast, int* colFirst, int* colLast);
	@spec xlAutoFilterGetRef(reference()) :: [integer()]
	def xlAutoFilterGetRef(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlAutoFilterSetRef(AutoFilterHandle handle, int rowFirst, int rowLast, int colFirst, int colLast);
	@spec xlAutoFilterSetRef(reference(), integer(), integer(), integer(), integer()) :: nil
	def xlAutoFilterSetRef(_handle, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# FilterColumnHandle xlAutoFilterColumn(AutoFilterHandle handle, int colId);
	@spec xlAutoFilterColumn(reference(), integer()) :: reference() | nil
	def xlAutoFilterColumn(_handle, _colId), do: :erlang.nif_error(:nif_not_loaded)
	# int xlAutoFilterColumnSize(AutoFilterHandle handle);
	@spec xlAutoFilterColumnSize(reference()) :: integer()
	def xlAutoFilterColumnSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# FilterColumnHandle xlAutoFilterColumnByIndex(AutoFilterHandle handle, int index);
	@spec xlAutoFilterColumnByIndex(reference(), integer()) :: reference() | nil
	def xlAutoFilterColumnByIndex(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlAutoFilterGetSortRange(AutoFilterHandle handle, int* rowFirst, int* rowLast, int* colFirst, int* colLast);
	@spec xlAutoFilterGetSortRange(reference()) :: [integer()]
	def xlAutoFilterGetSortRange(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlAutoFilterGetSort(AutoFilterHandle handle, int* columnIndex, int* descending);
	@spec xlAutoFilterGetSort(reference()) :: [integer()]
	def xlAutoFilterGetSort(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlAutoFilterSetSort(AutoFilterHandle handle, int columnIndex, int descending);
	@spec xlAutoFilterSetSort(reference(), integer(), integer()) :: integer()
	def xlAutoFilterSetSort(_handle, _columnIndex, _descending), do: :erlang.nif_error(:nif_not_loaded)
	# int xlAutoFilterAddSort(AutoFilterHandle handle, int columnIndex, int descending);
	@spec xlAutoFilterAddSort(reference(), integer(), integer()) :: integer()
	def xlAutoFilterAddSort(_handle, _columnIndex, _descending), do: :erlang.nif_error(:nif_not_loaded)

	# ========================================================================================================================================================

	# int xlFilterColumnIndex(FilterColumnHandle handle);
	@spec xlFilterColumnIndex(reference()) :: integer()
	def xlFilterColumnIndex(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFilterColumnFilterType(FilterColumnHandle handle);
	@spec xlFilterColumnFilterType(reference()) :: integer()
	def xlFilterColumnFilterType(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFilterColumnFilterSize(FilterColumnHandle handle);
	@spec xlFilterColumnFilterSize(reference()) :: integer()
	def xlFilterColumnFilterSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFilterColumnFilter(FilterColumnHandle handle, int index);
	@spec xlFilterColumnFilter(reference(), integer()) :: String.t()
	def xlFilterColumnFilter(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFilterColumnAddFilter(FilterColumnHandle handle, const wchar_t* value);
	@spec xlFilterColumnAddFilter(reference(), String.t()) :: nil
	def xlFilterColumnAddFilter(_handle, _value), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFilterColumnGetTop10(FilterColumnHandle handle, double* value, int* top, int* percent);
	@spec xlFilterColumnGetTop10(reference()) :: [any()]
	def xlFilterColumnGetTop10(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFilterColumnSetTop10(FilterColumnHandle handle, double value, int top, int percent);
	@spec xlFilterColumnSetTop10(reference(), float(), integer(), integer()) :: nil
	def xlFilterColumnSetTop10(_handle, _value, _top, _percent), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFilterColumnGetCustomFilter(FilterColumnHandle handle, int* op1, const wchar_t** v1, int* op2, const wchar_t** v2, int* andOp);
	@spec xlFilterColumnGetCustomFilter(reference()) :: [any()]
	def xlFilterColumnGetCustomFilter(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFilterColumnSetCustomFilter(FilterColumnHandle handle, int op, const wchar_t* val);
	@spec xlFilterColumnSetCustomFilter(reference(), integer(), String.t()) :: nil
	def xlFilterColumnSetCustomFilter(_handle, _op, _val), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFilterColumnSetCustomFilterEx(FilterColumnHandle handle, int op1, const wchar_t* v1, int op2, const wchar_t* v2, int andOp);
	@spec xlFilterColumnSetCustomFilterEx(reference(), integer(), String.t(), integer(), String.t(), integer()) :: nil
	def xlFilterColumnSetCustomFilterEx(_handle, _op1, _v1, _op2, _v2, _andOp), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFilterColumnClear(FilterColumnHandle handle);
	@spec xlFilterColumnClear(reference()) :: nil
	def xlFilterColumnClear(_handle), do: :erlang.nif_error(:nif_not_loaded)

	# ========================================================================================================================================================

	# int xlFontSize(FontHandle handle);
	@spec xlFontSize(reference()) :: integer()
	def xlFontSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFontSetSize(FontHandle handle, int size);
	@spec xlFontSetSize(reference(), integer()) :: nil
	def xlFontSetSize(_handle, _size), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFontItalic(FontHandle handle);
	@spec xlFontItalic(reference()) :: integer()
	def xlFontItalic(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFontSetItalic(FontHandle handle, int italic);
	@spec xlFontSetItalic(reference(), integer()) :: nil
	def xlFontSetItalic(_handle, _italic), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFontStrikeOut(FontHandle handle);
	@spec xlFontStrikeOut(reference()) :: integer()
	def xlFontStrikeOut(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFontSetStrikeOut(FontHandle handle, int strikeOut);
	@spec xlFontSetStrikeOut(reference(), integer()) :: nil
	def xlFontSetStrikeOut(_handle, _strikeOut), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFontColor(FontHandle handle);
	@spec xlFontColor(reference()) :: integer()
	def xlFontColor(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFontSetColor(FontHandle handle, int color);
	@spec xlFontSetColor(reference(), integer()) :: nil
	def xlFontSetColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFontBold(FontHandle handle);
	@spec xlFontBold(reference()) :: integer()
	def xlFontBold(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFontSetBold(FontHandle handle, int bold);
	@spec xlFontSetBold(reference(), integer()) :: nil
	def xlFontSetBold(_handle, _bold), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFontScript(FontHandle handle);
	@spec xlFontScript(reference()) :: integer()
	def xlFontScript(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFontSetScript(FontHandle handle, int script);
	@spec xlFontSetScript(reference(), integer()) :: nil
	def xlFontSetScript(_handle, _script), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFontUnderline(FontHandle handle);
	@spec xlFontUnderline(reference()) :: integer()
	def xlFontUnderline(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFontSetUnderline(FontHandle handle, int underline);
	@spec xlFontSetUnderline(reference(), integer()) :: nil
	def xlFontSetUnderline(_handle, _underline), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFontName(FontHandle handle);
	@spec xlFontName(reference()) :: integer()
	def xlFontName(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFontSetName(FontHandle handle, const wchar_t* name);
	@spec xlFontSetName(reference(), String.t()) :: nil
	def xlFontSetName(_handle, _name), do: :erlang.nif_error(:nif_not_loaded)

	# ========================================================================================================================================================

	# int xlFormControlObjectType(FormControlHandle handle);
	@spec xlFormControlObjectType(reference()) :: integer()
	def xlFormControlObjectType(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlChecked(FormControlHandle handle);
	@spec xlFormControlChecked(reference()) :: integer()
	def xlFormControlChecked(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetChecked(FormControlHandle handle, int checked);
	@spec xlFormControlSetChecked(reference(), integer()) :: nil
	def xlFormControlSetChecked(_handle, _checked), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlFmlaGroup(FormControlHandle handle);
	@spec xlFormControlFmlaGroup(reference()) :: String.t()
	def xlFormControlFmlaGroup(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetFmlaGroup(FormControlHandle handle, const wchar_t* group);
	@spec xlFormControlSetFmlaGroup(reference(), String.t()) :: nil
	def xlFormControlSetFmlaGroup(_handle, _group), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlFmlaLink(FormControlHandle handle);
	@spec xlFormControlFmlaLink(reference()) :: String.t()
	def xlFormControlFmlaLink(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetFmlaLink(FormControlHandle handle, const wchar_t* link);
	@spec xlFormControlSetFmlaLink(reference(), String.t()) :: nil
	def xlFormControlSetFmlaLink(_handle, _link), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlFmlaRange(FormControlHandle handle);
	@spec xlFormControlFmlaRange(reference()) :: String.t()
	def xlFormControlFmlaRange(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetFmlaRange(FormControlHandle handle, const wchar_t* range);
	@spec xlFormControlSetFmlaRange(reference(), String.t()) :: nil
	def xlFormControlSetFmlaRange(_handle, _range), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlFmlaTxbx(FormControlHandle handle);
	@spec xlFormControlFmlaTxbx(reference()) :: String.t()
	def xlFormControlFmlaTxbx(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetFmlaTxbx(FormControlHandle handle, const wchar_t* txbx);
	@spec xlFormControlSetFmlaTxbx(reference(), String.t()) :: nil
	def xlFormControlSetFmlaTxbx(_handle, _txbx), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlName(FormControlHandle handle);
	@spec xlFormControlName(reference()) :: String.t()
	def xlFormControlName(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlLinkedCell(FormControlHandle handle);
	@spec xlFormControlLinkedCell(reference()) :: String.t()
	def xlFormControlLinkedCell(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlListFillRange(FormControlHandle handle);
	@spec xlFormControlListFillRange(reference()) :: String.t()
	def xlFormControlListFillRange(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlMacro(FormControlHandle handle);
	@spec xlFormControlMacro(reference()) :: String.t()
	def xlFormControlMacro(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlAltText(FormControlHandle handle);
	@spec xlFormControlAltText(reference()) :: String.t()
	def xlFormControlAltText(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlLocked(FormControlHandle handle);
	@spec xlFormControlLocked(reference()) :: integer()
	def xlFormControlLocked(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlDefaultSize(FormControlHandle handle);
	@spec xlFormControlDefaultSize(reference()) :: integer()
	def xlFormControlDefaultSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlPrint(FormControlHandle handle);
	@spec xlFormControlPrint(reference()) :: integer()
	def xlFormControlPrint(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlDisabled(FormControlHandle handle);
	@spec xlFormControlDisabled(reference()) :: integer()
	def xlFormControlDisabled(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlItem(FormControlHandle handle, int index);
	@spec xlFormControlItem(reference(), integer()) :: String.t()
	def xlFormControlItem(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlItemSize(FormControlHandle handle);
	@spec xlFormControlItemSize(reference()) :: integer()
	def xlFormControlItemSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlAddItem(FormControlHandle handle, const wchar_t* value);
	@spec xlFormControlAddItem(reference(), String.t()) :: nil
	def xlFormControlAddItem(_handle, _value), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlInsertItem(FormControlHandle handle, int index, const wchar_t* value);
	@spec xlFormControlInsertItem(reference(), integer(), String.t()) :: nil
	def xlFormControlInsertItem(_handle, _index, _value), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlClearItems(FormControlHandle handle);
	@spec xlFormControlClearItems(reference()) :: nil
	def xlFormControlClearItems(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlDropLines(FormControlHandle handle);
	@spec xlFormControlDropLines(reference()) :: integer()
	def xlFormControlDropLines(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetDropLines(FormControlHandle handle, int lines);
	@spec xlFormControlSetDropLines(reference(), integer()) :: nil
	def xlFormControlSetDropLines(_handle, _lines), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlDx(FormControlHandle handle);
	@spec xlFormControlDx(reference()) :: integer()
	def xlFormControlDx(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetDx(FormControlHandle handle, int dx);
	@spec xlFormControlSetDx(reference(), integer()) :: nil
	def xlFormControlSetDx(_handle, _dx), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlFirstButton(FormControlHandle handle);
	@spec xlFormControlFirstButton(reference()) :: integer()
	def xlFormControlFirstButton(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetFirstButton(FormControlHandle handle, int firstButton);
	@spec xlFormControlSetFirstButton(reference(), integer()) :: nil
	def xlFormControlSetFirstButton(_handle, _firstButton), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlHoriz(FormControlHandle handle);
	@spec xlFormControlHoriz(reference()) :: integer()
	def xlFormControlHoriz(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetHoriz(FormControlHandle handle, int horiz);
	@spec xlFormControlSetHoriz(reference(), integer()) :: nil
	def xlFormControlSetHoriz(_handle, _horiz), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlInc(FormControlHandle handle);
	@spec xlFormControlInc(reference()) :: integer()
	def xlFormControlInc(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetInc(FormControlHandle handle, int inc);
	@spec xlFormControlSetInc(reference(), integer()) :: nil
	def xlFormControlSetInc(_handle, _inc), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlGetMax(FormControlHandle handle);
	@spec xlFormControlGetMax(reference()) :: integer()
	def xlFormControlGetMax(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetMax(FormControlHandle handle, int max);
	@spec xlFormControlSetMax(reference(), integer()) :: nil
	def xlFormControlSetMax(_handle, _max), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlGetMin(FormControlHandle handle);
	@spec xlFormControlGetMin(reference()) :: integer()
	def xlFormControlGetMin(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetMin(FormControlHandle handle, int min);
	@spec xlFormControlSetMin(reference(), integer()) :: nil
	def xlFormControlSetMin(_handle, _min), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlFormControlMultiSel(FormControlHandle handle);
	@spec xlFormControlMultiSel(reference()) :: String.t()
	def xlFormControlMultiSel(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetMultiSel(FormControlHandle handle, const wchar_t* value);
	@spec xlFormControlSetMultiSel(reference(), String.t()) :: nil
	def xlFormControlSetMultiSel(_handle, _value), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlSel(FormControlHandle handle);
	@spec xlFormControlSel(reference()) :: integer()
	def xlFormControlSel(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormControlSetSel(FormControlHandle handle, int sel);
	@spec xlFormControlSetSel(reference(), integer()) :: nil
	def xlFormControlSetSel(_handle, _sel), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlFromAnchor(FormControlHandle handle, int* col, int* colOff, int* row, int* rowOff);
	@spec xlFormControlFromAnchor(reference()) :: [any()]
	def xlFormControlFromAnchor(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormControlToAnchor(FormControlHandle handle, int* col, int* colOff, int* row, int* rowOff);
	@spec xlFormControlToAnchor(reference()) :: [any()]
	def xlFormControlToAnchor(_handle), do: :erlang.nif_error(:nif_not_loaded)

	# ========================================================================================================================================================

	# FontHandle xlFormatFont(FormatHandle handle);
	@spec xlFormatFont(reference()) :: reference() | nil
	def xlFormatFont(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatSetFont(FormatHandle handle, FontHandle fontHandle);
	@spec xlFormatSetFont(reference(), reference()) :: integer()
	def xlFormatSetFont(_handle, _fontHandle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatNumFormat(FormatHandle handle);
	@spec xlFormatNumFormat(reference()) :: integer()
	def xlFormatNumFormat(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetNumFormat(FormatHandle handle, int numFormat);
	@spec xlFormatSetNumFormat(reference(), integer()) :: nil
	def xlFormatSetNumFormat(_handle, _numFormat), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatAlignH(FormatHandle handle);
	@spec xlFormatAlignH(reference()) :: integer()
	def xlFormatAlignH(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetAlignH(FormatHandle handle, int align);
	@spec xlFormatSetAlignH(reference(), integer()) :: nil
	def xlFormatSetAlignH(_handle, _align), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatAlignV(FormatHandle handle);
	@spec xlFormatAlignV(reference()) :: integer()
	def xlFormatAlignV(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetAlignV(FormatHandle handle, int align);
	@spec xlFormatSetAlignV(reference(), integer()) :: nil
	def xlFormatSetAlignV(_handle, _align), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatWrap(FormatHandle handle);
	@spec xlFormatWrap(reference()) :: integer()
	def xlFormatWrap(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetWrap(FormatHandle handle, int wrap);
	@spec xlFormatSetWrap(reference(), integer()) :: nil
	def xlFormatSetWrap(_handle, _wrap), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatRotation(FormatHandle handle);
	@spec xlFormatRotation(reference()) :: integer()
	def xlFormatRotation(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatSetRotation(FormatHandle handle, int rotation);
	@spec xlFormatSetRotation(reference(), integer()) :: integer()
	def xlFormatSetRotation(_handle, _rotation), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatIndent(FormatHandle handle);
	@spec xlFormatIndent(reference()) :: integer()
	def xlFormatIndent(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetIndent(FormatHandle handle, int indent);
	@spec xlFormatSetIndent(reference(), integer()) :: nil
	def xlFormatSetIndent(_handle, _indent), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatShrinkToFit(FormatHandle handle);
	@spec xlFormatShrinkToFit(reference()) :: integer()
	def xlFormatShrinkToFit(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetShrinkToFit(FormatHandle handle, int shrinkToFit);
	@spec xlFormatSetShrinkToFit(reference(), integer()) :: nil
	def xlFormatSetShrinkToFit(_handle, _shrinkToFit), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorder(FormatHandle handle, int style);
	@spec xlFormatSetBorder(reference(), integer()) :: nil
	def xlFormatSetBorder(_handle, _style), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderColor(FormatHandle handle, int color);
	@spec xlFormatSetBorderColor(reference(), integer()) :: nil
	def xlFormatSetBorderColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderLeft(FormatHandle handle);
	@spec xlFormatBorderLeft(reference()) :: integer()
	def xlFormatBorderLeft(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderLeft(FormatHandle handle, int style);
	@spec xlFormatSetBorderLeft(reference(), integer()) :: nil
	def xlFormatSetBorderLeft(_handle, _style), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderRight(FormatHandle handle);
	@spec xlFormatBorderRight(reference()) :: integer()
	def xlFormatBorderRight(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderRight(FormatHandle handle, int style);
	@spec xlFormatSetBorderRight(reference(), integer()) :: nil
	def xlFormatSetBorderRight(_handle, _style), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderTop(FormatHandle handle);
	@spec xlFormatBorderTop(reference()) :: integer()
	def xlFormatBorderTop(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderTop(FormatHandle handle, int style);
	@spec xlFormatSetBorderTop(reference(), integer()) :: nil
	def xlFormatSetBorderTop(_handle, _style), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderBottom(FormatHandle handle);
	@spec xlFormatBorderBottom(reference()) :: integer()
	def xlFormatBorderBottom(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderBottom(FormatHandle handle, int style);
	@spec xlFormatSetBorderBottom(reference(), integer()) :: nil
	def xlFormatSetBorderBottom(_handle, _style), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderLeftColor(FormatHandle handle);
	@spec xlFormatBorderLeftColor(reference()) :: integer()
	def xlFormatBorderLeftColor(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderLeftColor(FormatHandle handle, int color);
	@spec xlFormatSetBorderLeftColor(reference(), integer()) :: nil
	def xlFormatSetBorderLeftColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderRightColor(FormatHandle handle);
	@spec xlFormatBorderRightColor(reference()) :: integer()
	def xlFormatBorderRightColor(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderRightColor(FormatHandle handle, int color);
	@spec xlFormatSetBorderRightColor(reference(), integer()) :: nil
	def xlFormatSetBorderRightColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderTopColor(FormatHandle handle);
	@spec xlFormatBorderTopColor(reference()) :: integer()
	def xlFormatBorderTopColor(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderTopColor(FormatHandle handle, int color);
	@spec xlFormatSetBorderTopColor(reference(), integer()) :: nil
	def xlFormatSetBorderTopColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderBottomColor(FormatHandle handle);
	@spec xlFormatBorderBottomColor(reference()) :: integer()
	def xlFormatBorderBottomColor(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderBottomColor(FormatHandle handle, int color);
	@spec xlFormatSetBorderBottomColor(reference(), integer()) :: nil
	def xlFormatSetBorderBottomColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderDiagonal(FormatHandle handle);
	@spec xlFormatBorderDiagonal(reference()) :: integer()
	def xlFormatBorderDiagonal(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderDiagonal(FormatHandle handle, int border);
	@spec xlFormatSetBorderDiagonal(reference(), integer()) :: nil
	def xlFormatSetBorderDiagonal(_handle, _border), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderDiagonalStyle(FormatHandle handle);
	@spec xlFormatBorderDiagonalStyle(reference()) :: integer()
	def xlFormatBorderDiagonalStyle(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderDiagonalStyle(FormatHandle handle, int style);
	@spec xlFormatSetBorderDiagonalStyle(reference(), integer()) :: nil
	def xlFormatSetBorderDiagonalStyle(_handle, _style), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatBorderDiagonalColor(FormatHandle handle);
	@spec xlFormatBorderDiagonalColor(reference()) :: integer()
	def xlFormatBorderDiagonalColor(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetBorderDiagonalColor(FormatHandle handle, int color);
	@spec xlFormatSetBorderDiagonalColor(reference(), integer()) :: nil
	def xlFormatSetBorderDiagonalColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatFillPattern(FormatHandle handle);
	@spec xlFormatFillPattern(reference()) :: integer()
	def xlFormatFillPattern(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetFillPattern(FormatHandle handle, int pattern);
	@spec xlFormatSetFillPattern(reference(), integer()) :: nil
	def xlFormatSetFillPattern(_handle, _pattern), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatPatternForegroundColor(FormatHandle handle);
	@spec xlFormatPatternForegroundColor(reference()) :: integer()
	def xlFormatPatternForegroundColor(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetPatternForegroundColor(FormatHandle handle, int color);
	@spec xlFormatSetPatternForegroundColor(reference(), integer()) :: nil
	def xlFormatSetPatternForegroundColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatPatternBackgroundColor(FormatHandle handle);
	@spec xlFormatPatternBackgroundColor(reference()) :: integer()
	def xlFormatPatternBackgroundColor(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetPatternBackgroundColor(FormatHandle handle, int color);
	@spec xlFormatSetPatternBackgroundColor(reference(), integer()) :: nil
	def xlFormatSetPatternBackgroundColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatLocked(FormatHandle handle);
	@spec xlFormatLocked(reference()) :: integer()
	def xlFormatLocked(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetLocked(FormatHandle handle, int locked);
	@spec xlFormatSetLocked(reference(), integer()) :: nil
	def xlFormatSetLocked(_handle, _locked), do: :erlang.nif_error(:nif_not_loaded)
	# int xlFormatHidden(FormatHandle handle);
	@spec xlFormatHidden(reference()) :: integer()
	def xlFormatHidden(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlFormatSetHidden(FormatHandle handle, int hidden);
	@spec xlFormatSetHidden(reference(), integer()) :: nil
	def xlFormatSetHidden(_handle, _hidden), do: :erlang.nif_error(:nif_not_loaded)

	# ========================================================================================================================================================

	# FontHandle xlRichStringAddFont(RichStringHandle handle, FontHandle initFont);
	@spec xlRichStringAddFont(reference(), reference() | nil) :: reference() | nil
	def xlRichStringAddFont(_handle, _initFont), do: :erlang.nif_error(:nif_not_loaded)
	# void xlRichStringAddText(RichStringHandle handle, const wchar_t* text, FontHandle font);
	@spec xlRichStringAddText(reference(), String.t(), reference()) :: nil
	def xlRichStringAddText(_handle, _text, _font), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlRichStringGetText(RichStringHandle handle, int index, FontHandle* font);
	@spec xlRichStringGetText(reference(), integer(), reference()) :: String.t()
	def xlRichStringGetText(_handle, _index, _font), do: :erlang.nif_error(:nif_not_loaded)
	# int xlRichStringTextSize(RichStringHandle handle);
	@spec xlRichStringTextSize(reference()) :: integer()
	def xlRichStringTextSize(_handle), do: :erlang.nif_error(:nif_not_loaded)

	# ========================================================================================================================================================

	# int xlSheetCellType(SheetHandle handle, int row, int col);
	@spec xlSheetCellType(reference(), integer(), integer()) :: integer()
	def xlSheetCellType(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetIsFormula(SheetHandle handle, int row, int col);
	@spec xlSheetIsFormula(reference(), integer(), integer()) :: integer()
	def xlSheetIsFormula(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# FormatHandle xlSheetCellFormat(SheetHandle handle, int row, int col);
	@spec xlSheetCellFormat(reference(), integer(), integer()) :: reference() | nil
	def xlSheetCellFormat(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetCellFormat(SheetHandle handle, int row, int col, FormatHandle format);
	@spec xlSheetSetCellFormat(reference(), integer(), integer(), reference() | nil) :: nil
	def xlSheetSetCellFormat(_handle, _row, _col, _format), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetReadStr(SheetHandle handle, int row, int col, FormatHandle* format);
	@spec xlSheetReadStr(reference(), reference(), reference()) :: [any()]
	def xlSheetReadStr(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteStr(SheetHandle handle, int row, int col, const wchar_t* value, FormatHandle format);
	@spec xlSheetWriteStr(reference(), integer(), integer(), String.t(), reference() | nil) :: integer()
	def xlSheetWriteStr(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteStrAsNum(SheetHandle handle, int row, int col, const wchar_t* value, FormatHandle format);
	@spec xlSheetWriteStrAsNum(reference(), integer(), integer(), String.t(), reference() | nil) :: integer()
	def xlSheetWriteStrAsNum(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded)
	# RichStringHandle xlSheetReadRichStr(SheetHandle handle, int row, int col, FormatHandle* format);
	@spec xlSheetReadRichStr(reference(), integer(), integer()) :: [any()]
	def xlSheetReadRichStr(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteRichStr(SheetHandle handle, int row, int col, RichStringHandle richString, FormatHandle format);
	@spec xlSheetWriteRichStr(reference(), integer(), integer(), reference(), reference() | nil) :: integer()
	def xlSheetWriteRichStr(_handle, _row, _col, _richString, _format), do: :erlang.nif_error(:nif_not_loaded)
	# double xlSheetReadNum(SheetHandle handle, int row, int col, FormatHandle* format);
	@spec xlSheetReadNum(reference(), integer(), integer()) :: [any()]
	def xlSheetReadNum(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteNum(SheetHandle handle, int row, int col, double value, FormatHandle format);
	@spec xlSheetWriteNum(reference(), integer(), integer(), float(), reference() | nil) :: integer()
	def xlSheetWriteNum(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetReadBool(SheetHandle handle, int row, int col, FormatHandle* format);
	@spec xlSheetReadBool(reference(), integer(), integer()) :: [any()]
	def xlSheetReadBool(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteBool(SheetHandle handle, int row, int col, int value, FormatHandle format);
	@spec xlSheetWriteBool(reference(), integer(), integer(), integer(), reference() | nil) :: integer()
	def xlSheetWriteBool(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetReadBlank(SheetHandle handle, int row, int col, FormatHandle* format);
	@spec xlSheetReadBlank(reference(), integer(), integer()) :: [any()]
	def xlSheetReadBlank(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteBlank(SheetHandle handle, int row, int col, FormatHandle format);
	@spec xlSheetWriteBlank(reference(), integer(), integer(), reference() | nil) :: integer()
	def xlSheetWriteBlank(_handle, _row, _col, _format), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetReadFormula(SheetHandle handle, int row, int col, FormatHandle* format);
	@spec xlSheetReadFormula(reference(), integer(), integer()) :: [any()]
	def xlSheetReadFormula(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteFormula(SheetHandle handle, int row, int col, const wchar_t* value, FormatHandle format);
	@spec xlSheetWriteFormula(reference(), integer(), integer(), String.t(), reference() | nil) :: integer()
	def xlSheetWriteFormula(_handle, _row, _col, _value, _format), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteFormulaNum(SheetHandle handle, int row, int col, const wchar_t* expr, double value, FormatHandle format);
	@spec xlSheetWriteFormulaNum(reference(), integer(), integer(), String.t(), float(), reference() | nil) :: integer()
	def xlSheetWriteFormulaNum(_handle, _row, _col, _expr, _value, _format), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteFormulaStr(SheetHandle handle, int row, int col, const wchar_t* expr, const wchar_t* value, FormatHandle format);
	@spec xlSheetWriteFormulaStr(reference(), integer(), integer(), String.t(), String.t(), reference() | nil) :: integer()
	def xlSheetWriteFormulaStr(_handle, _row, _col, _expr, _value, _format), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetWriteFormulaBool(SheetHandle handle, int row, int col, const wchar_t* expr, int value, FormatHandle format);
	@spec xlSheetWriteFormulaBool(reference(), integer(), integer(), String.t(), integer(), reference() | nil) :: integer()
	def xlSheetWriteFormulaBool(_handle, _row, _col, _expr, _value, _format), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetReadComment(SheetHandle handle, int row, int col);
	@spec xlSheetReadComment(reference(), integer(), integer()) :: integer()
	def xlSheetReadComment(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetWriteComment(SheetHandle handle, int row, int col, const wchar_t* value, const wchar_t* author, int width, int height);
	@spec xlSheetWriteComment(reference(), integer(), integer(), String.t(), String.t(), integer(), integer()) :: nil
	def xlSheetWriteComment(_handle, _row, _col, _value, _author, _width, _height), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetRemoveComment(SheetHandle handle, int row, int col);
	@spec xlSheetRemoveComment(reference(), integer(), integer()) :: nil
	def xlSheetRemoveComment(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetIsDate(SheetHandle handle, int row, int col);
	@spec xlSheetIsDate(reference(),integer(), integer() ) :: integer()
	def xlSheetIsDate(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetIsRichStr(SheetHandle handle, int row, int col);
	@spec xlSheetIsRichStr(reference(),integer(), integer() ) :: integer()
	def xlSheetIsRichStr(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetReadError(SheetHandle handle, int row, int col);
	@spec xlSheetReadError(reference(),integer(), integer() ) :: integer()
	def xlSheetReadError(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetWriteError(SheetHandle handle, int row, int col, int error, FormatHandle format);
	@spec xlSheetWriteError(reference(), integer(), integer(), integer(), reference() | nil) :: nil
	def xlSheetWriteError(_handle, _row, _col, _error, _format), do: :erlang.nif_error(:nif_not_loaded)
	# double xlSheetColWidth(SheetHandle handle, int col);
	@spec xlSheetColWidth(reference(), integer()) :: integer()
	def xlSheetColWidth(_handle, _col), do: :erlang.nif_error(:nif_not_loaded)
	# double xlSheetRowHeight(SheetHandle handle, int row);
	@spec xlSheetRowHeight(reference(), integer()) :: integer()
	def xlSheetRowHeight(_handle, _row), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetColWidthPx(SheetHandle handle, int col);
	@spec xlSheetColWidthPx(reference(), integer()) :: integer()
	def xlSheetColWidthPx(_handle, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetRowHeightPx(SheetHandle handle, int row);
	@spec xlSheetRowHeightPx(reference(), integer()) :: integer()
	def xlSheetRowHeightPx(_handle, _row), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetCol(SheetHandle handle, int colFirst, int colLast, double width, FormatHandle format, int hidden);
	@spec xlSheetSetCol(reference(), integer(), integer(), float(), reference(), integer()) :: integer()
	def xlSheetSetCol(_handle, _colFirst, _colLast, _width, _format, _hidden), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetRow(SheetHandle handle, int row, double height, FormatHandle format, int hidden);
	@spec xlSheetSetRow(reference(), integer(), float(), reference() | nil, integer()) :: integer()
	def xlSheetSetRow(_handle, _row, _height, _format, _hidden), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetRowHidden(SheetHandle handle, int row);
	@spec xlSheetRowHidden(reference(), integer()) :: integer()
	def xlSheetRowHidden(_handle, _row), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetRowHidden(SheetHandle handle, int row, int hidden);
	@spec xlSheetSetRowHidden(reference(), integer(), integer()) :: integer()
	def xlSheetSetRowHidden(_handle, _row, _hidden), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetColHidden(SheetHandle handle, int col);
	@spec xlSheetColHidden(reference(), integer()) :: integer()
	def xlSheetColHidden(_handle, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetColHidden(SheetHandle handle, int col, int hidden);
	@spec xlSheetSetColHidden(reference(), integer(), integer()) :: integer()
	def xlSheetSetColHidden(_handle, _col, _hidden), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGetMerge(SheetHandle handle, int row, int col, int* rowFirst, int* rowLast, int* colFirst, int* colLast);
	@spec xlSheetGetMerge(reference(), integer(), integer()) :: [any()]
	def xlSheetGetMerge(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetMerge(SheetHandle handle, int rowFirst, int rowLast, int colFirst, int colLast);
	@spec xlSheetSetMerge(reference(),integer(), integer(), integer(), integer() ) :: integer()
	def xlSheetSetMerge(_handle, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetDelMerge(SheetHandle handle, int row, int col);
	@spec xlSheetDelMerge(reference(),integer(), integer() ) :: integer()
	def xlSheetDelMerge(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetMergeSize(SheetHandle handle);
	@spec xlSheetMergeSize(reference()) :: integer()
	def xlSheetMergeSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetMerge(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast);
	@spec xlSheetMerge(reference(), integer()) :: [any()]
	def xlSheetMerge(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetDelMergeByIndex(SheetHandle handle, int index);
	@spec xlSheetDelMergeByIndex(reference(), integer()) :: integer()
	def xlSheetDelMergeByIndex(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetPictureSize(SheetHandle handle);
	@spec xlSheetPictureSize(reference()) :: integer()
	def xlSheetPictureSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGetPicture(SheetHandle handle, int index, int* rowTop, int* colLeft, int* rowBottom, int* colRight, int* width, int* height, int* offset_x, int* offset_y);
	@spec xlSheetGetPicture(reference(), integer()) :: [any()]
	def xlSheetGetPicture(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetRemovePictureByIndex(SheetHandle handle, int index);
	@spec xlSheetRemovePictureByIndex(reference(), integer()) :: integer()
	def xlSheetRemovePictureByIndex(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPicture(SheetHandle handle, int row, int col, int pictureId, double scale, int offset_x, int offset_y, int pos);
	@spec xlSheetSetPicture(reference(), integer(), integer(), integer(), float(), integer(), integer(), integer()) :: nil
	def xlSheetSetPicture(_handle, _row, _col, _pictureId, _scale, _offset_x, _offset_y, _pos), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPicture2(SheetHandle handle, int row, int col, int pictureId, int width, int height, int offset_x, int offset_y, int pos);
	@spec xlSheetSetPicture2(reference(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer()) :: nil
	def xlSheetSetPicture2(_handle, _row, _col, _pictureId, _width, _height, _offset_x, _offset_y, _pos), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetRemovePicture(SheetHandle handle, int row, int col);
	@spec xlSheetRemovePicture(reference(),integer(), integer() ) :: integer()
	def xlSheetRemovePicture(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGetHorPageBreak(SheetHandle handle, int index);
	@spec xlSheetGetHorPageBreak(reference(), integer()) :: integer()
	def xlSheetGetHorPageBreak(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGetHorPageBreakSize(SheetHandle handle);
	@spec xlSheetGetHorPageBreakSize(reference()) :: integer()
	def xlSheetGetHorPageBreakSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGetVerPageBreak(SheetHandle handle, int index);
	@spec xlSheetGetVerPageBreak(reference(), integer()) :: integer()
	def xlSheetGetVerPageBreak(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGetVerPageBreakSize(SheetHandle handle);
	@spec xlSheetGetVerPageBreakSize(reference()) :: integer()
	def xlSheetGetVerPageBreakSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetHorPageBreak(SheetHandle handle, int row, int pageBreak);
	@spec xlSheetSetHorPageBreak(reference(), integer(), integer()) :: integer()
	def xlSheetSetHorPageBreak(_handle, _row, _pageBreak), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetVerPageBreak(SheetHandle handle, int col, int pageBreak);
	@spec xlSheetSetVerPageBreak(reference(), integer(), integer()) :: integer()
	def xlSheetSetVerPageBreak(_handle, _col, _pageBreak), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSplit(SheetHandle handle, int row, int col);
	@spec xlSheetSplit(reference(), integer(), integer()) :: nil
	def xlSheetSplit(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSplitInfo(SheetHandle handle, int* row, int* col);
	@spec xlSheetSplitInfo(reference()) :: [any()]
	def xlSheetSplitInfo(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGroupRows(SheetHandle handle, int rowFirst, int rowLast, int collapsed);
	@spec xlSheetGroupRows(reference(), integer(), integer(), integer()) :: integer()
	def xlSheetGroupRows(_handle, _rowFirst, _rowLast, _collapsed), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGroupCols(SheetHandle handle, int colFirst, int colLast, int collapsed);
	@spec xlSheetGroupCols(reference(), integer(), integer(), integer()) :: integer()
	def xlSheetGroupCols(_handle, _colFirst, _colLast, _collapsed), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGroupSummaryBelow(SheetHandle handle);
	@spec xlSheetGroupSummaryBelow(reference()) :: integer()
	def xlSheetGroupSummaryBelow(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetGroupSummaryBelow(SheetHandle handle, int below);
	@spec xlSheetSetGroupSummaryBelow(reference(), integer()) :: nil
	def xlSheetSetGroupSummaryBelow(_handle, _below), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGroupSummaryRight(SheetHandle handle);
	@spec xlSheetGroupSummaryRight(reference()) :: integer()
	def xlSheetGroupSummaryRight(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetGroupSummaryRight(SheetHandle handle, int right);
	@spec xlSheetSetGroupSummaryRight(reference(), integer()) :: nil
	def xlSheetSetGroupSummaryRight(_handle, _right), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetClear(SheetHandle handle, int rowFirst, int rowLast, int colFirst, int colLast);
	@spec xlSheetClear(reference(),integer(), integer(), integer(), integer() ) :: integer()
	def xlSheetClear(_handle, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetInsertCol(SheetHandle handle, int colFirst, int colLast);
	@spec xlSheetInsertCol(reference(), integer(), integer()) :: integer()
	def xlSheetInsertCol(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetInsertRow(SheetHandle handle, int rowFirst, int rowLast);
	@spec xlSheetInsertRow(reference(), integer(), integer()) :: integer()
	def xlSheetInsertRow(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetRemoveCol(SheetHandle handle, int colFirst, int colLast);
	@spec xlSheetRemoveCol(reference(), integer(), integer()) :: integer()
	def xlSheetRemoveCol(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetRemoveRow(SheetHandle handle, int rowFirst, int rowLast);
	@spec xlSheetRemoveRow(reference(), integer(), integer()) :: integer()
	def xlSheetRemoveRow(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetInsertColAndKeepRanges(SheetHandle handle, int colFirst, int colLast);
	@spec xlSheetInsertColAndKeepRanges(reference(), integer(), integer()) :: integer()
	def xlSheetInsertColAndKeepRanges(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetInsertRowAndKeepRanges(SheetHandle handle, int rowFirst, int rowLast);
	@spec xlSheetInsertRowAndKeepRanges(reference(), integer(), integer()) :: integer()
	def xlSheetInsertRowAndKeepRanges(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetRemoveColAndKeepRanges(SheetHandle handle, int colFirst, int colLast);
	@spec xlSheetRemoveColAndKeepRanges(reference(), integer(), integer()) :: integer()
	def xlSheetRemoveColAndKeepRanges(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetRemoveRowAndKeepRanges(SheetHandle handle, int rowFirst, int rowLast);
	@spec xlSheetRemoveRowAndKeepRanges(reference(), integer(), integer()) :: integer()
	def xlSheetRemoveRowAndKeepRanges(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetCopyCell(SheetHandle handle, int rowSrc, int colSrc, int rowDst, int colDst);
	@spec xlSheetCopyCell(reference(), integer(), integer(), integer(), integer()) :: integer()
	def xlSheetCopyCell(_handle, _rowSrc, _colSrc, _rowDst, _colDst), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetFirstRow(SheetHandle handle);
	@spec xlSheetFirstRow(reference()) :: integer()
	def xlSheetFirstRow(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetLastRow(SheetHandle handle);
	@spec xlSheetLastRow(reference()) :: integer()
	def xlSheetLastRow(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetFirstCol(SheetHandle handle);
	@spec xlSheetFirstCol(reference()) :: integer()
	def xlSheetFirstCol(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetLastCol(SheetHandle handle);
	@spec xlSheetLastCol(reference()) :: integer()
	def xlSheetLastCol(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetFirstFilledRow(SheetHandle handle);
	@spec xlSheetFirstFilledRow(reference()) :: integer()
	def xlSheetFirstFilledRow(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetLastFilledRow(SheetHandle handle);
	@spec xlSheetLastFilledRow(reference()) :: integer()
	def xlSheetLastFilledRow(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetFirstFilledCol(SheetHandle handle);
	@spec xlSheetFirstFilledCol(reference()) :: integer()
	def xlSheetFirstFilledCol(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetLastFilledCol(SheetHandle handle);
	@spec xlSheetLastFilledCol(reference()) :: integer()
	def xlSheetLastFilledCol(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetDisplayGridlines(SheetHandle handle);
	@spec xlSheetDisplayGridlines(reference()) :: integer()
	def xlSheetDisplayGridlines(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetDisplayGridlines(SheetHandle handle, int show);
	@spec xlSheetSetDisplayGridlines(reference(), integer()) :: nil
	def xlSheetSetDisplayGridlines(_handle, _show), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetPrintGridlines(SheetHandle handle);
	@spec xlSheetPrintGridlines(reference()) :: integer()
	def xlSheetPrintGridlines(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPrintGridlines(SheetHandle handle, int print);
	@spec xlSheetSetPrintGridlines(reference(), integer()) :: nil
	def xlSheetSetPrintGridlines(_handle, _print), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetZoom(SheetHandle handle);
	@spec xlSheetZoom(reference()) :: integer()
	def xlSheetZoom(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetZoom(SheetHandle handle, int zoom);
	@spec xlSheetSetZoom(reference(), integer()) :: nil
	def xlSheetSetZoom(_handle, _zoom), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetPrintZoom(SheetHandle handle);
	@spec xlSheetPrintZoom(reference()) :: integer()
	def xlSheetPrintZoom(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPrintZoom(SheetHandle handle, int zoom);
	@spec xlSheetSetPrintZoom(reference(), integer()) :: nil
	def xlSheetSetPrintZoom(_handle, _zoom), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGetPrintFit(SheetHandle handle, int* wPages, int* hPages);
	@spec xlSheetGetPrintFit(reference()) :: [any()]
	def xlSheetGetPrintFit(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPrintFit(SheetHandle handle, int wPages, int hPages);
	@spec xlSheetSetPrintFit(reference(), integer(), integer()) :: nil
	def xlSheetSetPrintFit(_handle, _wPages, _hPages), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetLandscape(SheetHandle handle);
	@spec xlSheetLandscape(reference()) :: integer()
	def xlSheetLandscape(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetLandscape(SheetHandle handle, int landscape);
	@spec xlSheetSetLandscape(reference(), integer()) :: nil
	def xlSheetSetLandscape(_handle, _landscape), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetPaper(SheetHandle handle);
	@spec xlSheetPaper(reference()) :: integer()
	def xlSheetPaper(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPaper(SheetHandle handle, int paper);
	@spec xlSheetSetPaper(reference(), integer()) :: nil
	def xlSheetSetPaper(_handle, _paper), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetHeader(SheetHandle handle);
	@spec xlSheetHeader(reference()) :: integer()
	def xlSheetHeader(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetHeader(SheetHandle handle, const wchar_t* header, double margin);
	@spec xlSheetSetHeader(reference(), String.t(), integer()) :: integer()
	def xlSheetSetHeader(_handle, _header, _margin), do: :erlang.nif_error(:nif_not_loaded)
	# double xlSheetHeaderMargin(SheetHandle handle);
	@spec xlSheetHeaderMargin(reference()) :: integer()
	def xlSheetHeaderMargin(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetFooter(SheetHandle handle);
	@spec xlSheetFooter(reference()) :: integer()
	def xlSheetFooter(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetFooter(SheetHandle handle, const wchar_t* footer, double margin);
	@spec xlSheetSetFooter(reference(), String.t(), integer()) :: integer()
	def xlSheetSetFooter(_handle, _footer, _margin), do: :erlang.nif_error(:nif_not_loaded)
	# double xlSheetFooterMargin(SheetHandle handle);
	@spec xlSheetFooterMargin(reference()) :: integer()
	def xlSheetFooterMargin(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetHCenter(SheetHandle handle);
	@spec xlSheetHCenter(reference()) :: integer()
	def xlSheetHCenter(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetHCenter(SheetHandle handle, int hCenter);
	@spec xlSheetSetHCenter(reference(), integer()) :: nil
	def xlSheetSetHCenter(_handle, _hCenter), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetVCenter(SheetHandle handle);
	@spec xlSheetVCenter(reference()) :: integer()
	def xlSheetVCenter(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetVCenter(SheetHandle handle, int vCenter);
	@spec xlSheetSetVCenter(reference(), integer()) :: nil
	def xlSheetSetVCenter(_handle, _vCenter), do: :erlang.nif_error(:nif_not_loaded)
	# double xlSheetMarginLeft(SheetHandle handle);
	@spec xlSheetMarginLeft(reference()) :: integer()
	def xlSheetMarginLeft(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetMarginLeft(SheetHandle handle, double margin);
	@spec xlSheetSetMarginLeft(reference(), float()) :: nil
	def xlSheetSetMarginLeft(_handle, _margin), do: :erlang.nif_error(:nif_not_loaded)
	# double xlSheetMarginRight(SheetHandle handle);
	@spec xlSheetMarginRight(reference()) :: integer()
	def xlSheetMarginRight(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetMarginRight(SheetHandle handle, double margin);
	@spec xlSheetSetMarginRight(reference(), float()) :: nil
	def xlSheetSetMarginRight(_handle, _margin), do: :erlang.nif_error(:nif_not_loaded)
	# double xlSheetMarginTop(SheetHandle handle);
	@spec xlSheetMarginTop(reference()) :: integer()
	def xlSheetMarginTop(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetMarginTop(SheetHandle handle, double margin);
	@spec xlSheetSetMarginTop(reference(), float()) :: nil
	def xlSheetSetMarginTop(_handle, _margin), do: :erlang.nif_error(:nif_not_loaded)
	# double xlSheetMarginBottom(SheetHandle handle);
	@spec xlSheetMarginBottom(reference()) :: integer()
	def xlSheetMarginBottom(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetMarginBottom(SheetHandle handle, double margin);
	@spec xlSheetSetMarginBottom(reference(), float()) :: nil
	def xlSheetSetMarginBottom(_handle, _margin), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetPrintRowCol(SheetHandle handle);
	@spec xlSheetPrintRowCol(reference()) :: integer()
	def xlSheetPrintRowCol(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPrintRowCol(SheetHandle handle, int print);
	@spec xlSheetSetPrintRowCol(reference(), integer()) :: nil
	def xlSheetSetPrintRowCol(_handle, _print), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetPrintRepeatRows(SheetHandle handle, int* rowFirst, int* rowLast);
	@spec xlSheetPrintRepeatRows(reference()) :: [any()]
	def xlSheetPrintRepeatRows(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPrintRepeatRows(SheetHandle handle, int rowFirst, int rowLast);
	@spec xlSheetSetPrintRepeatRows(reference(), integer(), integer()) :: nil
	def xlSheetSetPrintRepeatRows(_handle, _rowFirst, _rowLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetPrintRepeatCols(SheetHandle handle, int* colFirst, int* colLast);
	@spec xlSheetPrintRepeatCols(reference()) :: [any()]
	def xlSheetPrintRepeatCols(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPrintRepeatCols(SheetHandle handle, int colFirst, int colLast);
	@spec xlSheetSetPrintRepeatCols(reference(), integer(), integer()) :: nil
	def xlSheetSetPrintRepeatCols(_handle, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetPrintArea(SheetHandle handle, int* rowFirst, int* rowLast, int* colFirst, int* colLast);
	@spec xlSheetPrintArea(reference()) :: [any()]
	def xlSheetPrintArea(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetPrintArea(SheetHandle handle, int rowFirst, int rowLast, int colFirst, int colLast);
	@spec xlSheetSetPrintArea(reference(), integer(), integer(), integer(), integer()) :: nil
	def xlSheetSetPrintArea(_handle, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetClearPrintRepeats(SheetHandle handle);
	@spec xlSheetClearPrintRepeats(reference()) :: nil
	def xlSheetClearPrintRepeats(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetClearPrintArea(SheetHandle handle);
	@spec xlSheetClearPrintArea(reference()) :: nil
	def xlSheetClearPrintArea(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetGetNamedRange(SheetHandle handle, const wchar_t* name, int* rowFirst, int* rowLast, int* colFirst, int* colLast, int scopeId, int* hidden);
	@spec xlSheetGetNamedRange(reference(), String.t(), integer()) :: [any()]
	def xlSheetGetNamedRange(_handle, _name, _scopedId), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetNamedRange(SheetHandle handle, const wchar_t* name, int rowFirst, int rowLast, int colFirst, int colLast, int scopeId);
	@spec xlSheetSetNamedRange(reference(), String.t(), integer(), integer(), integer(), integer(), integer()) :: integer()
	def xlSheetSetNamedRange(_handle, _name, _rowFirst, _rowLast, _colFirst, _colLast, _scopeId), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetDelNamedRange(SheetHandle handle, const wchar_t* name, int scopeId);
	@spec xlSheetDelNamedRange(reference(), String.t(), integer()) :: integer()
	def xlSheetDelNamedRange(_handle, _name, _scopeId), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetNamedRangeSize(SheetHandle handle);
	@spec xlSheetNamedRangeSize(reference()) :: integer()
	def xlSheetNamedRangeSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetNamedRange(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast, int* scopeId, int* hidden);
	@spec xlSheetNamedRange(reference(), integer()) :: [any()]
	def xlSheetNamedRange(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetTableSize(SheetHandle handle);
	@spec xlSheetTableSize(reference()) :: integer()
	def xlSheetTableSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetTable(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast, int* headerRowCount, int* totalsRowCount);
	@spec xlSheetTable(reference(), integer()) :: [any()]
	def xlSheetTable(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetHyperlinkSize(SheetHandle handle);
	@spec xlSheetHyperlinkSize(reference()) :: integer()
	def xlSheetHyperlinkSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetHyperlink(SheetHandle handle, int index, int* rowFirst, int* rowLast, int* colFirst, int* colLast);
	@spec xlSheetHyperlink(reference(), integer()) :: [any()]
	def xlSheetHyperlink(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetDelHyperlink(SheetHandle handle, int index);
	@spec xlSheetDelHyperlink(reference(), integer()) :: integer()
	def xlSheetDelHyperlink(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetAddHyperlink(SheetHandle handle, const wchar_t* hyperlink, int rowFirst, int rowLast, int colFirst, int colLast);
	@spec xlSheetAddHyperlink(reference(), String.t(), integer(), integer(), integer(), integer()) :: nil
	def xlSheetAddHyperlink(_handle, _hyperlink, _rowFirst, _rowLast, _colFirst, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetIsAutoFilter(SheetHandle handle);
	@spec xlSheetIsAutoFilter(reference()) :: integer()
	def xlSheetIsAutoFilter(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# AutoFilterHandle xlSheetAutoFilter(SheetHandle handle);
	@spec xlSheetAutoFilter(reference()) :: integer()
	def xlSheetAutoFilter(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetApplyFilter(SheetHandle handle);
	@spec xlSheetApplyFilter(reference()) :: nil
	def xlSheetApplyFilter(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetRemoveFilter(SheetHandle handle);
	@spec xlSheetRemoveFilter(reference()) :: nil
	def xlSheetRemoveFilter(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetName(SheetHandle handle);
	@spec xlSheetName(reference()) :: integer()
	def xlSheetName(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetName(SheetHandle handle, const wchar_t* name);
	@spec xlSheetSetName(reference(), String.t()) :: nil
	def xlSheetSetName(_handle, _name), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetProtect(SheetHandle handle);
	@spec xlSheetProtect(reference()) :: integer()
	def xlSheetProtect(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetProtect(SheetHandle handle, int protect);
	@spec xlSheetSetProtect(reference(), integer()) :: nil
	def xlSheetSetProtect(_handle, _protect), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetProtectEx(SheetHandle handle, int protect, const wchar_t* password, int enhancedProtection);
	@spec xlSheetSetProtectEx(reference(), integer(), String.t(), integer()) :: nil
	def xlSheetSetProtectEx(_handle, _protect, _password, _enhancedProtection), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetHidden(SheetHandle handle);
	@spec xlSheetHidden(reference()) :: integer()
	def xlSheetHidden(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetSetHidden(SheetHandle handle, int hidden);
	@spec xlSheetSetHidden(reference(), integer()) :: integer()
	def xlSheetSetHidden(_handle, _hidden), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetGetTopLeftView(SheetHandle handle, int* row, int* col);
	@spec xlSheetGetTopLeftView(reference()) :: [any()]
	def xlSheetGetTopLeftView(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetTopLeftView(SheetHandle handle, int row, int col);
	@spec xlSheetSetTopLeftView(reference(), integer(), integer()) :: nil
	def xlSheetSetTopLeftView(_handle, _row, _col), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetRightToLeft(SheetHandle handle);
	@spec xlSheetRightToLeft(reference()) :: integer()
	def xlSheetRightToLeft(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetRightToLeft(SheetHandle handle, int rightToLeft);
	@spec xlSheetSetRightToLeft(reference(), integer()) :: nil
	def xlSheetSetRightToLeft(_handle, _rightToLeft), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetAutoFitArea(SheetHandle handle, int rowFirst, int colFirst, int rowLast, int colLast);
	@spec xlSheetSetAutoFitArea(reference(), integer(), integer(), integer(), integer()) :: nil
	def xlSheetSetAutoFitArea(_handle, _rowFirst, _colFirst, _rowLast, _colLast), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetAddrToRowCol(SheetHandle handle, const wchar_t* addr, int* row, int* col, int* rowRelative, int* colRelative);
	@spec xlSheetAddrToRowCol(reference(), String.t()) :: [any()]
	def xlSheetAddrToRowCol(_handle, _addr), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlSheetRowColToAddr(SheetHandle handle, int row, int col, int rowRelative, int colRelative);
	@spec xlSheetRowColToAddr(reference(), String.t(), String.t(), String.t(), String.t()) :: integer()
	def xlSheetRowColToAddr(_handle, _row, _col, _rowRelative, _colRelative), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetTabColor(SheetHandle handle, int color);
	@spec xlSheetSetTabColor(reference(), String.t()) :: nil
	def xlSheetSetTabColor(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetSetTabRgbColor(SheetHandle handle, int red, int green, int blue);
	@spec xlSheetSetTabRgbColor(reference(), String.t(), String.t(), String.t()) :: nil
	def xlSheetSetTabRgbColor(_handle, _red, _green, _blue), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetAddIgnoredError(SheetHandle handle, int rowFirst, int colFirst, int rowLast, int colLast, int iError);
	@spec xlSheetAddIgnoredError(reference(), String.t(), String.t(), String.t(), String.t(), String.t()) :: integer()
	def xlSheetAddIgnoredError(_handle, _rowFirst, _colFirst, _rowLast, _colLast, _iError), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetAddDataValidation(SheetHandle handle, int type, int op, int rowFirst, int rowLast, int colFirst, int colLast, const wchar_t* value1, const wchar_t* value2);
	@spec xlSheetAddDataValidation(reference(), String.t(), String.t(), String.t(), String.t(), String.t(), String.t(), String.t(), String.t()) :: nil
	def xlSheetAddDataValidation(_handle, _type, _op, _rowFirst, _rowLast, _colFirst, _colLast, _value1, _value2), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetAddDataValidationEx(SheetHandle handle, int type, int op, int rowFirst, int rowLast, int colFirst, int colLast, const wchar_t* value1, const wchar_t* value2, int allowBlank, int hideDropDown, int showInputMessage, int showErrorMessage, const wchar_t* promptTitle, const wchar_t* prompt, const wchar_t* errorTitle, const wchar_t* error, int errorStyle);
	@spec xlSheetAddDataValidationEx(reference(), integer(), integer(), integer(), integer(), integer(), integer(), String.t(), String.t(), integer(), integer(), integer(), integer(), String.t(), String.t(), String.t(), String.t(), integer()) :: nil
	def xlSheetAddDataValidationEx(_handle, _type, _op, _rowFirst, _rowLast, _colFirst, _colLast, _value1, _value2, _allowBlank, _hideDropDown, _showInputMessage, _showErrorMessage, _promptTitle, _prompt, _errorTitle, _error, _errorStyle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetAddDataValidationDouble(SheetHandle handle, int type, int op, int rowFirst, int rowLast, int colFirst, int colLast, double value1, double value2);
	@spec xlSheetAddDataValidationDouble(reference(), integer(), integer(), integer(), integer(), integer(), integer(), float(), float()) :: nil
	def xlSheetAddDataValidationDouble(_handle, _type, _op, _rowFirst, _rowLast, _colFirst, _colLast, _value1, _value2), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetAddDataValidationDoubleEx(SheetHandle handle, int type, int op, int rowFirst, int rowLast, int colFirst, int colLast, double value1, double value2, int allowBlank, int hideDropDown, int showInputMessage, int showErrorMessage, const wchar_t* promptTitle, const wchar_t* prompt, const wchar_t* errorTitle, const wchar_t* error, int errorStyle);
	@spec xlSheetAddDataValidationDoubleEx(reference(), integer(), integer(), integer(), integer(), integer(), integer(), float(), float(), integer(), integer(), integer(), integer(), String.t(), String.t(), String.t(), String.t(), integer()) :: nil
	def xlSheetAddDataValidationDoubleEx(_handle, _type, _op, _rowFirst, _rowLast, _colFirst, _colLast, _value1, _value2, _allowBlank, _hideDropDown, _showInputMessage, _showErrorMessage, _promptTitle, _prompt, _errorTitle, _error, _errorStyle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlSheetRemoveDataValidations(SheetHandle handle);
	@spec xlSheetRemoveDataValidations(reference()) :: nil
	def xlSheetRemoveDataValidations(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlSheetFormControlSize(SheetHandle handle);
	@spec xlSheetFormControlSize(reference()) :: integer()
	def xlSheetFormControlSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# FormControlHandle xlSheetFormControl(SheetHandle handle, int index);
	@spec xlSheetFormControl(reference(), integer()) :: reference() | nil
	def xlSheetFormControl(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)

	# ========================================================================================================================================================

	# BookHandle xlCreateBook(void);
	@spec xlCreateBook() :: reference() | nil
	def xlCreateBook(), do: :erlang.nif_error(:nif_not_loaded)
	# BookHandle xlCreateXMLBook(void);
	@spec xlCreateXMLBook() :: reference() | nil
	def xlCreateXMLBook(), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookLoad(BookHandle handle, const wchar_t* filename);
	@spec xlBookLoad(reference(), String.t()) :: integer()
	def xlBookLoad(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookSave(BookHandle handle, const wchar_t* filename);
	@spec xlBookSave(reference(), String.t()) :: integer()
	def xlBookSave(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookLoadUsingTempFile(BookHandle handle, const wchar_t* filename, const wchar_t* tempFile);
	@spec xlBookLoadUsingTempFile(reference(), String.t(), String.t()) :: integer()
	def xlBookLoadUsingTempFile(_handle, _filename, _tempfile), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookSaveUsingTempFile(BookHandle handle, const wchar_t* filename, int useTempFile);
	@spec xlBookSaveUsingTempFile(reference(), String.t(), integer()) :: integer()
	def xlBookSaveUsingTempFile(_handle, _filename, _usetempfile), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookLoadPartially(BookHandle handle, const wchar_t* filename, int sheetIndex, int firstRow, int lastRow, int keepAllSheets);
	@spec xlBookLoadPartially(reference(), String.t(), integer(), integer(), integer(), integer()) :: integer()
	def xlBookLoadPartially(_handle, _filename, _sheetindex, _firstrow, _lastrow, _keepAllSheets), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookLoadPartiallyUsingTempFile(BookHandle handle, const wchar_t* filename, int sheetIndex, int firstRow, int lastRow, const wchar_t* tempFile, int keepAllSheets);
	@spec xlBookLoadPartiallyUsingTempFile(reference(), String.t(), integer(), integer(), integer(), String.t(), integer()) :: integer()
	def xlBookLoadPartiallyUsingTempFile(_handle, _filename, _sheetindex, _firstrow, _lastrow, _tempfile, _keepAllSheets), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookLoadWithoutEmptyCells(BookHandle handle, const wchar_t* filename);
	@spec xlBookLoadWithoutEmptyCells(reference(), String.t()) :: integer()
	def xlBookLoadWithoutEmptyCells(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookLoadInfo(BookHandle handle, const wchar_t* filename);
	@spec xlBookLoadInfo(reference(), String.t()) :: integer()
	def xlBookLoadInfo(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookLoadRaw(BookHandle handle, const char* data, unsigned size);
	@spec xlBookLoadRaw(reference(), String.t(), integer()) :: integer()
	def xlBookLoadRaw(_handle, _data, _size), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookLoadRawPartially(BookHandle handle, const char* data, unsigned size, int sheetIndex, int firstRow, int lastRow, int keepAllSheets);
	@spec xlBookLoadRawPartially(reference(), String.t(), integer(), integer(), integer(), integer(), integer()) :: integer()
	def xlBookLoadRawPartially(_handle, _data, _size, _sheetindex, _firstrow, _lastrow, _keepAllSheets), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookSaveRaw(BookHandle handle, const char** data, unsigned* size);
	@spec xlBookSaveRaw(reference()) :: [any()]
	def xlBookSaveRaw(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# SheetHandle xlBookAddSheet(BookHandle handle, const wchar_t* name, SheetHandle initSheet);
	@spec xlBookAddSheet(reference(), String.t(), reference() | nil) :: integer()
	def xlBookAddSheet(_handle, _name, _initsheet), do: :erlang.nif_error(:nif_not_loaded)
	# SheetHandle xlBookInsertSheet(BookHandle handle, int index, const wchar_t* name, SheetHandle initSheet);
	@spec xlBookInsertSheet(reference(), integer(), String.t(), reference() | nil) :: integer()
	def xlBookInsertSheet(_handle, _index, _name, _initsheet), do: :erlang.nif_error(:nif_not_loaded)
	# SheetHandle xlBookGetSheet(BookHandle handle, int index);
	@spec xlBookGetSheet(reference(), integer()) :: integer()
	def xlBookGetSheet(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlBookGetSheetName(BookHandle handle, int index);
	@spec xlBookGetSheetName(reference(), integer()) :: integer()
	def xlBookGetSheetName(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookSheetType(BookHandle handle, int index);
	@spec xlBookSheetType(reference(), integer()) :: integer()
	def xlBookSheetType(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookMoveSheet(BookHandle handle, int srcIndex, int dstIndex);
	@spec xlBookMoveSheet(reference(), integer(), integer()) :: integer()
	def xlBookMoveSheet(_handle, _srcindex, _dstindex), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookDelSheet(BookHandle handle, int index);
	@spec xlBookDelSheet(reference(), integer()) :: integer()
	def xlBookDelSheet(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookSheetCount(BookHandle handle);
	@spec xlBookSheetCount(reference()) :: integer()
	def xlBookSheetCount(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# FormatHandle xlBookAddFormat(BookHandle handle, FormatHandle initFormat);
	@spec xlBookAddFormat(reference(), reference() | nil) :: integer()
	def xlBookAddFormat(_handle, _initformat), do: :erlang.nif_error(:nif_not_loaded)
	# FontHandle xlBookAddFont(BookHandle handle, FontHandle initFont);
	@spec xlBookAddFont(reference(), reference() | nil) :: integer()
	def xlBookAddFont(_handle, _initfont), do: :erlang.nif_error(:nif_not_loaded)
	# RichStringHandle xlBookAddRichString(BookHandle handle);
	@spec xlBookAddRichString(reference()) :: integer()
	def xlBookAddRichString(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookAddCustomNumFormat(BookHandle handle, const wchar_t* customNumFormat);
	@spec xlBookAddCustomNumFormat(reference(), String.t()) :: integer()
	def xlBookAddCustomNumFormat(_handle, _customnumformat), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlBookCustomNumFormat(BookHandle handle, int fmt);
	@spec xlBookCustomNumFormat(reference(), integer()) :: integer()
	def xlBookCustomNumFormat(_handle, _fmt), do: :erlang.nif_error(:nif_not_loaded)
	# FormatHandle xlBookFormat(BookHandle handle, int index);
	@spec xlBookFormat(reference(), integer()) :: integer()
	def xlBookFormat(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookFormatSize(BookHandle handle);
	@spec xlBookFormatSize(reference()) :: integer()
	def xlBookFormatSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# FontHandle xlBookFont(BookHandle handle, int index);
	@spec xlBookFont(reference(), integer()) :: integer()
	def xlBookFont(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookFontSize(BookHandle handle);
	@spec xlBookFontSize(reference()) :: integer()
	def xlBookFontSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	#  double xlBookDatePack(BookHandle handle, int year, int month, int day, int hour, int min, int sec, int msec);
	@spec xlBookDatePack(reference(), integer(), integer(), integer(), integer(), integer(), integer(), integer()) :: integer()
	def xlBookDatePack(_handle, _year, _month, _day, _hour, _min, _sec, _msec), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookDateUnpack(BookHandle handle, double value, int* year, int* month, int* day, int* hour, int* min, int* sec, int* msec);
	@spec xlBookDateUnpack(reference(), float()) :: [any()]
	def xlBookDateUnpack(_handle, _value), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookColorPack(BookHandle handle, int red, int green, int blue);
	@spec xlBookColorPack(reference(), integer(), integer(), integer()) :: integer()
	def xlBookColorPack(_handle, _red, _green, _blue), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookColorUnpack(BookHandle handle, int color);
	@spec xlBookColorUnpack(reference(), integer()) :: nil
	def xlBookColorUnpack(_handle, _color), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookActiveSheet(BookHandle handle);
	@spec xlBookActiveSheet(reference()) :: integer()
	def xlBookActiveSheet(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookSetActiveSheet(BookHandle handle, int index);
	@spec xlBookSetActiveSheet(reference(), integer()) :: nil
	def xlBookSetActiveSheet(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookPictureSize(BookHandle handle);
	@spec xlBookPictureSize(reference()) :: integer()
	def xlBookPictureSize(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookGetPicture(BookHandle handle, int index, const char** data, unsigned* size);
	@spec xlBookGetPicture(reference(), integer()) :: [any()]
	def xlBookGetPicture(_handle, _index), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookAddPicture(BookHandle handle, const wchar_t* filename);
	@spec xlBookAddPicture(reference(), String.t()) :: integer()
	def xlBookAddPicture(_handle, _filename), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookAddPicture2(BookHandle handle, const char* data, unsigned size);
	@spec xlBookAddPicture2(reference(), String.t(), integer()) :: integer()
	def xlBookAddPicture2(_handle, _data, _size), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookAddPictureAsLink(BookHandle handle, const wchar_t* filename, int insert);
	@spec xlBookAddPictureAsLink(reference(), String.t(), integer()) :: integer()
	def xlBookAddPictureAsLink(_handle, _filename, _insert), do: :erlang.nif_error(:nif_not_loaded)
	# const wchar_t* xlBookDefaultFont(BookHandle handle, int* fontSize);
	@spec xlBookDefaultFont(reference()) :: [any()]
	def xlBookDefaultFont(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookSetDefaultFont(BookHandle handle, const wchar_t* fontName, int fontSize);
	@spec xlBookSetDefaultFont(reference(), String.t(), integer()) :: nil
	def xlBookSetDefaultFont(_handle, _fontname, _fontsize), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookRefR1C1(BookHandle handle);
	@spec xlBookRefR1C1(reference()) :: integer()
	def xlBookRefR1C1(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookSetRefR1C1(BookHandle handle, int refR1C1);
	@spec xlBookSetRefR1C1(reference(), integer()) :: nil
	def xlBookSetRefR1C1(_handle, _refr1c1), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookSetKey(BookHandle handle, const wchar_t* name, const wchar_t* key);
	@spec xlBookSetKey(reference(), String.t(), String.t()) :: nil
	def xlBookSetKey(_handle, _name, _key), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookRgbMode(BookHandle handle);
	@spec xlBookRgbMode(reference()) :: integer()
	def xlBookRgbMode(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookSetRgbMode(BookHandle handle, int rgbMode);
	@spec xlBookSetRgbMode(reference(), integer()) :: nil
	def xlBookSetRgbMode(_handle, _rgbmode), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookCalcMode(BookHandle handle);
	@spec xlBookCalcMode(reference()) :: integer()
	def xlBookCalcMode(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookSetCalcMode(BookHandle handle, int calcMode);
	@spec xlBookSetCalcMode(reference(), integer()) :: nil
	def xlBookSetCalcMode(_handle, _calcmode), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookVersion(BookHandle handle);
	@spec xlBookVersion(reference()) :: integer()
	def xlBookVersion(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookBiffVersion(BookHandle handle);
	@spec xlBookBiffVersion(reference()) :: integer()
	def xlBookBiffVersion(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookIsDate1904(BookHandle handle);
	@spec xlBookIsDate1904(reference()) :: integer()
	def xlBookIsDate1904(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookSetDate1904(BookHandle handle, int date1904);
	@spec xlBookSetDate1904(reference(), integer()) :: nil
	def xlBookSetDate1904(_handle, _date1904), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookIsTemplate(BookHandle handle);
	@spec xlBookIsTemplate(reference()) :: integer()
	def xlBookIsTemplate(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookSetTemplate(BookHandle handle, int tmpl);
	@spec xlBookSetTemplate(reference(), integer()) :: nil
	def xlBookSetTemplate(_handle, _tmpl), do: :erlang.nif_error(:nif_not_loaded)
	# int xlBookSetLocale(BookHandle handle, const char* locale);
	@spec xlBookSetLocale(reference(), String.t()) :: integer()
	def xlBookSetLocale(_handle, _locate), do: :erlang.nif_error(:nif_not_loaded)
	# const char* xlBookErrorMessage(BookHandle handle);
	@spec xlBookErrorMessage(reference()) :: String.t()
	def xlBookErrorMessage(_handle), do: :erlang.nif_error(:nif_not_loaded)
	# void xlBookRelease(BookHandle handle);
	@spec xlBookRelease(reference()) :: nil
	def xlBookRelease(_handle), do: :erlang.nif_error(:nif_not_loaded)
end