/* This file is auto-genereated from a template file. If you want changes
* then edit the template file.
*
*/

#include <pybind11/numpy.h>
#include <pybind11/pybind11.h>
#include <pybind11/stl_bind.h>

PYBIND11_MAKE_OPAQUE(std::vector<int8_t>);
PYBIND11_MAKE_OPAQUE(std::vector<uint8_t>);
PYBIND11_MAKE_OPAQUE(std::vector<int16_t>);
PYBIND11_MAKE_OPAQUE(std::vector<uint16_t>);
PYBIND11_MAKE_OPAQUE(std::vector<int32_t>);
PYBIND11_MAKE_OPAQUE(std::vector<uint32_t>);
PYBIND11_MAKE_OPAQUE(std::vector<int64_t>);
PYBIND11_MAKE_OPAQUE(std::vector<uint64_t>);

PYBIND11_MAKE_OPAQUE(std::vector<float>);
PYBIND11_MAKE_OPAQUE(std::vector<double>);

/*
* Linux does not like the below line because unsigned long int and size_t are
* the same thing. Apple (clang) and Windows (MSVC) do not seem to have a problem
* with the line.
*/
#if defined(__APPLE__) 
PYBIND11_MAKE_OPAQUE(std::vector<size_t>);
#endif

#include <utility>

#include <QtCore/QString>

namespace py = pybind11;

PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);

namespace pybind11
{
namespace detail
{
/* Create a TypeCaster for auto python string <--> QString conversion */
template <> struct type_caster<QString>
{
public:
  /**
* This macro establishes the name 'QString' in
* function signatures and declares a local variable
* 'value' of type QString
*/
  PYBIND11_TYPE_CASTER(QString, _("QString"));

  /**
*  @brief Conversion part 1 (Python->C++): convert a PyObject into a QString
* instance or return false upon failure. The second argument
* indicates whether implicit conversions should be applied.
* @param src
* @return boolean
*/
  bool load(handle src, bool)
  {
    if(!src)
    {
      return false;
    }
    object temp;
    handle load_src = src;
    if(PyUnicode_Check(load_src.ptr()))
    {
      temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(load_src.ptr()));
      if(!temp) /* A UnicodeEncodeError occured */
      {
        PyErr_Clear();
        return false;
      }
      load_src = temp;
    }
    char* buffer = nullptr;
    ssize_t length = 0;
    int err = PYBIND11_BYTES_AS_STRING_AND_SIZE(load_src.ptr(), &buffer, &length);
    if(err == -1) /* A TypeError occured */
    {
      PyErr_Clear();
      return false;
    }
    value = QString::fromUtf8(buffer, static_cast<int>(length));
    return true;
  }

  /**
   * @brief Conversion part 2 (C++ -> Python): convert an QString instance into
   * a Python object. The second and third arguments are used to
   * indicate the return value policy and parent object (for
   * ``return_value_policy::reference_internal``) and are generally
   * ignored by implicit casters.
   *
   * @param src
   * @return
   */
  static handle cast(const QString& src, return_value_policy /* policy */, handle /* parent */)
  {
#if PY_VERSION_HEX >= 0x03030000 // Python 3.3
    assert(sizeof(QChar) == 2);
    return PyUnicode_FromKindAndData(PyUnicode_2BYTE_KIND, src.constData(), src.length());
#else
    QByteArray a = src.toUtf8();
    return PyUnicode_FromStringAndSize(a.data(), (ssize_t)a.length());
#endif
  }
};
}
}

#ifndef PySharedPtrClass_TEMPLATE
#define PySharedPtrClass_TEMPLATE
template <typename T> using PySharedPtrClass = py::class_<T, std::shared_ptr<T>>;
#endif

/* These are all the pybind11 headers for each for each of the exported classes */
#include "SIMPLib/Common/Observable_PY11.h"
#include "SIMPLib/Filtering/AbstractFilter_PY11.h"
#include "SIMPLib/CoreFilters/ArrayCalculator_PY11.h"
#include "SIMPLib/CoreFilters/Breakpoint_PY11.h"
#include "SIMPLib/CoreFilters/CombineAttributeArrays_PY11.h"
#include "SIMPLib/CoreFilters/CombineAttributeMatrices_PY11.h"
#include "SIMPLib/CoreFilters/ConditionalSetValue_PY11.h"
#include "SIMPLib/CoreFilters/ConvertData_PY11.h"
#include "SIMPLib/CoreFilters/CopyFeatureArrayToElementArray_PY11.h"
#include "SIMPLib/CoreFilters/CreateAttributeMatrix_PY11.h"
#include "SIMPLib/CoreFilters/CreateDataArray_PY11.h"
#include "SIMPLib/CoreFilters/CreateDataContainer_PY11.h"
#include "SIMPLib/CoreFilters/CreateFeatureArrayFromElementArray_PY11.h"
#include "SIMPLib/CoreFilters/CreateImageGeometry_PY11.h"
#include "SIMPLib/CoreFilters/CreateStringArray_PY11.h"
#include "SIMPLib/CoreFilters/DataContainerReader_PY11.h"
#include "SIMPLib/CoreFilters/DataContainerWriter_PY11.h"
#include "SIMPLib/CoreFilters/EmptyFilter_PY11.h"
#include "SIMPLib/CoreFilters/ExecuteProcess_PY11.h"
#include "SIMPLib/CoreFilters/ExtractComponentAsArray_PY11.h"
#include "SIMPLib/CoreFilters/FeatureCountDecision_PY11.h"
#include "SIMPLib/CoreFilters/FeatureDataCSVWriter_PY11.h"
#include "SIMPLib/CoreFilters/FileWriter_PY11.h"
#include "SIMPLib/CoreFilters/FindDerivatives_PY11.h"
#include "SIMPLib/CoreFilters/GenerateColorTable_PY11.h"
#include "SIMPLib/CoreFilters/ImportAsciDataArray_PY11.h"
#include "SIMPLib/CoreFilters/ImportHDF5Dataset_PY11.h"
#include "SIMPLib/CoreFilters/LinkFeatureMapToElementArray_PY11.h"
#include "SIMPLib/CoreFilters/MaskCountDecision_PY11.h"
#include "SIMPLib/CoreFilters/MoveData_PY11.h"
#include "SIMPLib/CoreFilters/MoveMultiData_PY11.h"
#include "SIMPLib/CoreFilters/MultiThresholdObjects_PY11.h"
#include "SIMPLib/CoreFilters/MultiThresholdObjects2_PY11.h"
#include "SIMPLib/CoreFilters/PipelineAnnotation_PY11.h"
#include "SIMPLib/CoreFilters/PostSlackMessage_PY11.h"
#include "SIMPLib/CoreFilters/RawBinaryReader_PY11.h"
#include "SIMPLib/CoreFilters/ReadASCIIData_PY11.h"
#include "SIMPLib/CoreFilters/RemoveArrays_PY11.h"
#include "SIMPLib/CoreFilters/RemoveComponentFromArray_PY11.h"
#include "SIMPLib/CoreFilters/RenameAttributeArray_PY11.h"
#include "SIMPLib/CoreFilters/RenameAttributeMatrix_PY11.h"
#include "SIMPLib/CoreFilters/RenameDataContainer_PY11.h"
#include "SIMPLib/CoreFilters/ReplaceValueInArray_PY11.h"
#include "SIMPLib/CoreFilters/RequiredZThickness_PY11.h"
#include "SIMPLib/CoreFilters/ScaleVolume_PY11.h"
#include "SIMPLib/CoreFilters/SetOriginResolutionImageGeom_PY11.h"
#include "SIMPLib/CoreFilters/WriteASCIIData_PY11.h"
#include "SIMPLib/CoreFilters/WriteTriangleGeometry_PY11.h"
#include "SIMPLib/TestFilters/ArraySelectionExample_PY11.h"
#include "SIMPLib/TestFilters/ChangeGlobalValue_PY11.h"
#include "SIMPLib/TestFilters/DynamicTableExample_PY11.h"
#include "SIMPLib/TestFilters/ErrorWarningFilter_PY11.h"
#include "SIMPLib/TestFilters/GenericExample_PY11.h"
#include "SIMPLib/TestFilters/MakeDataContainer_PY11.h"
#include "SIMPLib/TestFilters/ThresholdExample_PY11.h"
#include "SIMPLib/DataArrays/IDataArray_PY11.h"
#include "SIMPLib/DataContainers/AttributeMatrix_PY11.h"
#include "SIMPLib/DataContainers/DataArrayPath_PY11.h"
#include "SIMPLib/DataContainers/DataContainer_PY11.h"
#include "SIMPLib/DataContainers/DataContainerArray_PY11.h"
#include "SIMPLib/DataContainers/DataContainerArrayProxy_PY11.h"
#include "SIMPLib/Filtering/FilterPipeline_PY11.h"
#include "SIMPLib/Geometry/IGeometry_PY11.h"
#include "SIMPLib/Geometry/IGeometryGrid_PY11.h"
#include "SIMPLib/Geometry/ImageGeom_PY11.h"
#include "SIMPLib/Utilities/SIMPLH5DataReader_PY11.h"
#include "SIMPLib/Utilities/SIMPLH5DataReaderRequirements_PY11.h"


/******************************************************************************
*
******************************************************************************/

#include "SIMPLib/DataArrays/DataArray.hpp"

#define PYB11_DEFINE_DATAARRAY_INIT(T, NAME)                                                                                                                                                           \
  PySharedPtrClass<DataArray<T>> declare##NAME(py::module& m, PySharedPtrClass<IDataArray>& parent)                                                                                \
  {                                                                                                                                                                                                    \
    using DataArrayType = DataArray<T>;                                                                                                                                                                \
    PySharedPtrClass<DataArrayType> instance(m, #NAME, parent, py::buffer_protocol());                                                                                                                 \
    instance.def(py::init([](size_t numElements, QString name, bool allocate) { return DataArrayType::CreateArray(numElements, name, allocate); }))                                                    \
        .def(py::init([](T* ptr, size_t numElements, std::vector<size_t> cDims, QString name, bool ownsData) {                                                                                         \
          return DataArrayType::WrapPointer(ptr, numElements, QVector<size_t>::fromStdVector(cDims), name, ownsData);                                                                                  \
        }))                                                                                                                                                                                            \
        .def(py::init([](py::array_t<T, py::array::c_style> b, std::vector<size_t> cDims, QString name, bool ownsData) {                                                                               \
          ssize_t numElements = 1;                                                                                                                                                                     \
          ssize_t nDims = b.ndim();                                                                                                                                                                    \
          for(ssize_t e = 0; e < nDims; e++)                                                                                                                                                           \
          {                                                                                                                                                                                            \
            numElements *= b.shape(e);                                                                                                                                                                 \
          }                                                                                                                                                                                            \
          return DataArrayType::WrapPointer(reinterpret_cast<T*>(b.mutable_data(0)), static_cast<size_t>(numElements), QVector<size_t>::fromStdVector(cDims), name, ownsData);                         \
        })) /* Class instance method setValue */                                                                                                                                                       \
        .def("setValue", &DataArrayType::setValue, py::arg("index"), py::arg("value"))                                                                                                                 \
        .def("getValue", &DataArrayType::getValue, py::arg("index"))                                                                                                                                   \
        .def_property("Name", &DataArrayType::getName, &DataArrayType::setName);                                                                                                                       \
    ;                                                                                                                                                                                                  \
    return instance;                                                                                                                                                                                   \
  }

PYB11_DEFINE_DATAARRAY_INIT(int8_t, Int8ArrayType);
PYB11_DEFINE_DATAARRAY_INIT(uint8_t, UInt8ArrayType);

PYB11_DEFINE_DATAARRAY_INIT(int16_t, Int16ArrayType);
PYB11_DEFINE_DATAARRAY_INIT(uint16_t, UInt16ArrayType);

PYB11_DEFINE_DATAARRAY_INIT(int32_t, Int32ArrayType);
PYB11_DEFINE_DATAARRAY_INIT(uint32_t, UInt32ArrayType);

PYB11_DEFINE_DATAARRAY_INIT(int64_t, Int64ArrayType);
PYB11_DEFINE_DATAARRAY_INIT(uint64_t, UInt64ArrayType);

PYB11_DEFINE_DATAARRAY_INIT(float, FloatArrayType);
PYB11_DEFINE_DATAARRAY_INIT(double, DoubleArrayType);

/******************************************************************************
*
******************************************************************************/

/**
 * @brief PYBIND11_MODULE This section declares our python module, its name and
 * what classes are available within the module.
 *
 */
PYBIND11_MODULE(simpl_py, mod)
{
 // py::module mod = m.def_submodule("simpl_py");
  mod.doc() = "Python wrapping for SIMPL_PY";
  
  /* STL Binding code */
  py::bind_vector<std::vector<int8_t>>(mod, "VectorInt8");
  py::bind_vector<std::vector<uint8_t>>(mod, "VectorUInt8");

  py::bind_vector<std::vector<int16_t>>(mod, "VectorInt16");
  py::bind_vector<std::vector<uint16_t>>(mod, "VectorUInt16");

  py::bind_vector<std::vector<int32_t>>(mod, "VectorInt32");
  py::bind_vector<std::vector<uint32_t>>(mod, "VectorUInt32");

  py::bind_vector<std::vector<int64_t>>(mod, "VectorInt64");
  py::bind_vector<std::vector<uint64_t>>(mod, "VectorUInt64");

  py::bind_vector<std::vector<float>>(mod, "VectorFloat");
  py::bind_vector<std::vector<double>>(mod, "VectorDouble");
#if defined(__APPLE__) || defined (_WIN32)
  py::bind_vector<std::vector<size_t>>(mod, "VectorSizeT");
#endif
  /* Init codes for classes in the Module */
  /* These are all the pybind11 instantiations for each of the exported classes */
  PySharedPtrClass<Observable> simpl_py_Observable = declareObservable(mod);

  PySharedPtrClass<AbstractFilter> simpl_py_AbstractFilter = declareAbstractFilter(mod);
  PySharedPtrClass<ArrayCalculator> simpl_py_ArrayCalculator = declareArrayCalculator(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<Breakpoint> simpl_py_Breakpoint = declareBreakpoint(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<CombineAttributeArrays> simpl_py_CombineAttributeArrays = declareCombineAttributeArrays(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<CombineAttributeMatrices> simpl_py_CombineAttributeMatrices = declareCombineAttributeMatrices(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ConditionalSetValue> simpl_py_ConditionalSetValue = declareConditionalSetValue(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ConvertData> simpl_py_ConvertData = declareConvertData(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<CopyFeatureArrayToElementArray> simpl_py_CopyFeatureArrayToElementArray = declareCopyFeatureArrayToElementArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<CreateAttributeMatrix> simpl_py_CreateAttributeMatrix = declareCreateAttributeMatrix(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<CreateDataArray> simpl_py_CreateDataArray = declareCreateDataArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<CreateDataContainer> simpl_py_CreateDataContainer = declareCreateDataContainer(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<CreateFeatureArrayFromElementArray> simpl_py_CreateFeatureArrayFromElementArray = declareCreateFeatureArrayFromElementArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<CreateImageGeometry> simpl_py_CreateImageGeometry = declareCreateImageGeometry(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<CreateStringArray> simpl_py_CreateStringArray = declareCreateStringArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<DataContainerReader> simpl_py_DataContainerReader = declareDataContainerReader(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<DataContainerWriter> simpl_py_DataContainerWriter = declareDataContainerWriter(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<EmptyFilter> simpl_py_EmptyFilter = declareEmptyFilter(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ExecuteProcess> simpl_py_ExecuteProcess = declareExecuteProcess(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ExtractComponentAsArray> simpl_py_ExtractComponentAsArray = declareExtractComponentAsArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<FeatureCountDecision> simpl_py_FeatureCountDecision = declareFeatureCountDecision(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<FeatureDataCSVWriter> simpl_py_FeatureDataCSVWriter = declareFeatureDataCSVWriter(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<FileWriter> simpl_py_FileWriter = declareFileWriter(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<FindDerivatives> simpl_py_FindDerivatives = declareFindDerivatives(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<GenerateColorTable> simpl_py_GenerateColorTable = declareGenerateColorTable(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ImportAsciDataArray> simpl_py_ImportAsciDataArray = declareImportAsciDataArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ImportHDF5Dataset> simpl_py_ImportHDF5Dataset = declareImportHDF5Dataset(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<LinkFeatureMapToElementArray> simpl_py_LinkFeatureMapToElementArray = declareLinkFeatureMapToElementArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<MaskCountDecision> simpl_py_MaskCountDecision = declareMaskCountDecision(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<MoveData> simpl_py_MoveData = declareMoveData(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<MoveMultiData> simpl_py_MoveMultiData = declareMoveMultiData(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<MultiThresholdObjects> simpl_py_MultiThresholdObjects = declareMultiThresholdObjects(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<MultiThresholdObjects2> simpl_py_MultiThresholdObjects2 = declareMultiThresholdObjects2(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<PipelineAnnotation> simpl_py_PipelineAnnotation = declarePipelineAnnotation(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<PostSlackMessage> simpl_py_PostSlackMessage = declarePostSlackMessage(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<RawBinaryReader> simpl_py_RawBinaryReader = declareRawBinaryReader(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ReadASCIIData> simpl_py_ReadASCIIData = declareReadASCIIData(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<RemoveArrays> simpl_py_RemoveArrays = declareRemoveArrays(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<RemoveComponentFromArray> simpl_py_RemoveComponentFromArray = declareRemoveComponentFromArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<RenameAttributeArray> simpl_py_RenameAttributeArray = declareRenameAttributeArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<RenameAttributeMatrix> simpl_py_RenameAttributeMatrix = declareRenameAttributeMatrix(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<RenameDataContainer> simpl_py_RenameDataContainer = declareRenameDataContainer(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ReplaceValueInArray> simpl_py_ReplaceValueInArray = declareReplaceValueInArray(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<RequiredZThickness> simpl_py_RequiredZThickness = declareRequiredZThickness(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ScaleVolume> simpl_py_ScaleVolume = declareScaleVolume(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<SetOriginResolutionImageGeom> simpl_py_SetOriginResolutionImageGeom = declareSetOriginResolutionImageGeom(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<WriteASCIIData> simpl_py_WriteASCIIData = declareWriteASCIIData(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<WriteTriangleGeometry> simpl_py_WriteTriangleGeometry = declareWriteTriangleGeometry(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ArraySelectionExample> simpl_py_ArraySelectionExample = declareArraySelectionExample(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ChangeGlobalValue> simpl_py_ChangeGlobalValue = declareChangeGlobalValue(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<DynamicTableExample> simpl_py_DynamicTableExample = declareDynamicTableExample(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ErrorWarningFilter> simpl_py_ErrorWarningFilter = declareErrorWarningFilter(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<GenericExample> simpl_py_GenericExample = declareGenericExample(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<MakeDataContainer> simpl_py_MakeDataContainer = declareMakeDataContainer(mod, simpl_py_AbstractFilter);

  PySharedPtrClass<ThresholdExample> simpl_py_ThresholdExample = declareThresholdExample(mod, simpl_py_AbstractFilter);


  PySharedPtrClass<IDataArray> simpl_py_IDataArray = declareIDataArray(mod);

  PySharedPtrClass<AttributeMatrix> simpl_py_AttributeMatrix = declareAttributeMatrix(mod);

  PySharedPtrClass<DataArrayPath> simpl_py_DataArrayPath = declareDataArrayPath(mod);

  PySharedPtrClass<DataContainer> simpl_py_DataContainer = declareDataContainer(mod);

  PySharedPtrClass<DataContainerArray> simpl_py_DataContainerArray = declareDataContainerArray(mod);

  PySharedPtrClass<DataContainerArrayProxy> simpl_py_DataContainerArrayProxy = declareDataContainerArrayProxy(mod);

  PySharedPtrClass<FilterPipeline> simpl_py_FilterPipeline = declareFilterPipeline(mod);

  PySharedPtrClass<IGeometry> simpl_py_IGeometry = declareIGeometry(mod);
  PySharedPtrClass<IGeometryGrid> simpl_py_IGeometryGrid = declareIGeometryGrid(mod, simpl_py_IGeometry);

  PySharedPtrClass<ImageGeom> simpl_py_ImageGeom = declareImageGeom(mod, simpl_py_IGeometryGrid);


  PySharedPtrClass<SIMPLH5DataReader> simpl_py_SIMPLH5DataReader = declareSIMPLH5DataReader(mod);

  PySharedPtrClass<SIMPLH5DataReaderRequirements> simpl_py_SIMPLH5DataReaderRequirements = declareSIMPLH5DataReaderRequirements(mod);


  /* Init codes for the DataArray<T> classes */
  PySharedPtrClass<Int8ArrayType> simpl_py_Int8ArrayType = declareInt8ArrayType(mod, simpl_py_IDataArray);
  PySharedPtrClass<UInt8ArrayType> simpl_py_UInt8ArrayType = declareUInt8ArrayType(mod, simpl_py_IDataArray);

  PySharedPtrClass<Int16ArrayType> simpl_py_Int16ArrayType = declareInt16ArrayType(mod, simpl_py_IDataArray);
  PySharedPtrClass<UInt16ArrayType> simpl_py_UInt16ArrayType = declareUInt16ArrayType(mod, simpl_py_IDataArray);

  PySharedPtrClass<Int32ArrayType> simpl_py_Int32ArrayType = declareInt32ArrayType(mod, simpl_py_IDataArray);
  PySharedPtrClass<UInt32ArrayType> simpl_py_UInt32ArrayType = declareUInt32ArrayType(mod, simpl_py_IDataArray);

  PySharedPtrClass<Int64ArrayType> simpl_py_Int64ArrayType = declareInt64ArrayType(mod, simpl_py_IDataArray);
  PySharedPtrClass<UInt64ArrayType> simpl_py_UInt64ArrayType = declareUInt64ArrayType(mod, simpl_py_IDataArray);

  PySharedPtrClass<FloatArrayType> simpl_py_FloatArrayType = declareFloatArrayType(mod, simpl_py_IDataArray);
  PySharedPtrClass<DoubleArrayType> simpl_py_DoubleArrayType = declareDoubleArrayType(mod, simpl_py_IDataArray);

  py::enum_<SIMPL::InfoStringFormat>(mod, "InfoStringFormat").value("HtmlFormat", SIMPL::InfoStringFormat::HtmlFormat).value("UnknownFormat", SIMPL::InfoStringFormat::UnknownFormat).export_values();
}