tfcollins/definelibm2k_macos.m

## definelibm2k_macos.m
%% About definelibm2k.mlx
% This file defines the MATLAB interface to the library |libm2k|.
%
% Commented sections represent C++ functionality that MATLAB cannot automatically define. To include
% functionality, uncomment a section and provide values for &lt;SHAPE&gt;, &lt;DIRECTION&gt;, etc. For more
% information, see <matlab:helpview(fullfile(docroot,'matlab','helptargets.map'),'cpp_define_interface') Define MATLAB Interface for C++ Library>.


%% Setup. Do not edit this section.
function libDef = definelibm2k_macos()
libDef = clibgen.LibraryDefinition("libm2kData.xml");
%% OutputFolder and Libraries
libDef.OutputFolder = "/Users/analog/git/m2kmatlab/libm2k-matlab/mylib";
libDef.Libraries = "/Users/analog/git/m2kmatlab/libm2k-matlab/libm2k/libm2k.dylib";

%% C++ class |iio_channel| with MATLAB name |clib.libm2k.iio_channel|
iio_channelDefinition = addClass(libDef, "iio_channel", "MATLABName", "clib.libm2k.iio_channel", ...
    "Description", "clib.libm2k.iio_channel    Representation of C++ class iio_channel."); % Modify help description values as needed.

%% C++ class |iio_device| with MATLAB name |clib.libm2k.iio_device|
iio_deviceDefinition = addClass(libDef, "iio_device", "MATLABName", "clib.libm2k.iio_device", ...
    "Description", "clib.libm2k.iio_device    Representation of C++ class iio_device."); % Modify help description values as needed.

%% C++ class |iio_buffer| with MATLAB name |clib.libm2k.iio_buffer|
iio_bufferDefinition = addClass(libDef, "iio_buffer", "MATLABName", "clib.libm2k.iio_buffer", ...
    "Description", "clib.libm2k.iio_buffer    Representation of C++ class iio_buffer."); % Modify help description values as needed.

%% C++ class |iio_context| with MATLAB name |clib.libm2k.iio_context|
iio_contextDefinition = addClass(libDef, "iio_context", "MATLABName", "clib.libm2k.iio_context", ...
    "Description", "clib.libm2k.iio_context    Representation of C++ class iio_context."); % Modify help description values as needed.

%% C++ enumeration |ContextTypes| with MATLAB name |clib.libm2k.ContextTypes|
addEnumeration(libDef, "ContextTypes", "int32",...
    [...
      "CtxFMCOMMS",...  % 0
      "CtxM2K",...  % 1
      "CtxLIDAR",...  % 2
      "Other",...  % 3
    ],...
    "MATLABName", "clib.libm2k.ContextTypes", ...
    "Description", "clib.libm2k.ContextTypes    Representation of C++ enumeration ContextTypes."); % Modify help description values as needed.

%% C++ class |iio_context_info| with MATLAB name |clib.libm2k.iio_context_info|
iio_context_infoDefinition = addClass(libDef, "iio_context_info", "MATLABName", "clib.libm2k.iio_context_info", ...
    "Description", "clib.libm2k.iio_context_info    Representation of C++ class iio_context_info."); % Modify help description values as needed.

%% C++ class |iio_scan_context| with MATLAB name |clib.libm2k.iio_scan_context|
iio_scan_contextDefinition = addClass(libDef, "iio_scan_context", "MATLABName", "clib.libm2k.iio_scan_context", ...
    "Description", "clib.libm2k.iio_scan_context    Representation of C++ class iio_scan_context."); % Modify help description values as needed.

%% C++ class |iio_scan_block| with MATLAB name |clib.libm2k.iio_scan_block|
iio_scan_blockDefinition = addClass(libDef, "iio_scan_block", "MATLABName", "clib.libm2k.iio_scan_block", ...
    "Description", "clib.libm2k.iio_scan_block    Representation of C++ class iio_scan_block."); % Modify help description values as needed.

%% C++ enumeration |iio_chan_type| with MATLAB name |clib.libm2k.iio_chan_type|
addEnumeration(libDef, "iio_chan_type", "int32",...
    [...
      "IIO_VOLTAGE",...  % 0
      "IIO_CURRENT",...  % 1
      "IIO_POWER",...  % 2
      "IIO_ACCEL",...  % 3
      "IIO_ANGL_VEL",...  % 4
      "IIO_MAGN",...  % 5
      "IIO_LIGHT",...  % 6
      "IIO_INTENSITY",...  % 7
      "IIO_PROXIMITY",...  % 8
      "IIO_TEMP",...  % 9
      "IIO_INCLI",...  % 10
      "IIO_ROT",...  % 11
      "IIO_ANGL",...  % 12
      "IIO_TIMESTAMP",...  % 13
      "IIO_CAPACITANCE",...  % 14
      "IIO_ALTVOLTAGE",...  % 15
      "IIO_CCT",...  % 16
      "IIO_PRESSURE",...  % 17
      "IIO_HUMIDITYRELATIVE",...  % 18
      "IIO_ACTIVITY",...  % 19
      "IIO_STEPS",...  % 20
      "IIO_ENERGY",...  % 21
      "IIO_DISTANCE",...  % 22
      "IIO_VELOCITY",...  % 23
      "IIO_CONCENTRATION",...  % 24
      "IIO_RESISTANCE",...  % 25
      "IIO_PH",...  % 26
      "IIO_UVINDEX",...  % 27
      "IIO_ELECTRICALCONDUCTIVITY",...  % 28
      "IIO_COUNT",...  % 29
      "IIO_INDEX",...  % 30
      "IIO_GRAVITY",...  % 31
      "IIO_POSITIONRELATIVE",...  % 32
      "IIO_PHASE",...  % 33
      "IIO_MASSCONCENTRATION",...  % 34
      "IIO_CHAN_TYPE_UNKNOWN",...  % 2147483647
    ],...
    "MATLABName", "clib.libm2k.iio_chan_type", ...
    "Description", "clib.libm2k.iio_chan_type    Representation of C++ enumeration iio_chan_type." + newline + ...
    "IIO channel type", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "e" + newline + ...
    "" + newline + ...
    "A IIO channel has a type specifying the type of data associated with the" + newline + ...
    "channel."); % Modify help description values as needed.

%% C++ enumeration |iio_modifier| with MATLAB name |clib.libm2k.iio_modifier|
addEnumeration(libDef, "iio_modifier", "int32",...
    [...
      "IIO_NO_MOD",...  % 0
      "IIO_MOD_X",...  % 1
      "IIO_MOD_Y",...  % 2
      "IIO_MOD_Z",...  % 3
      "IIO_MOD_X_AND_Y",...  % 4
      "IIO_MOD_X_AND_Z",...  % 5
      "IIO_MOD_Y_AND_Z",...  % 6
      "IIO_MOD_X_AND_Y_AND_Z",...  % 7
      "IIO_MOD_X_OR_Y",...  % 8
      "IIO_MOD_X_OR_Z",...  % 9
      "IIO_MOD_Y_OR_Z",...  % 10
      "IIO_MOD_X_OR_Y_OR_Z",...  % 11
      "IIO_MOD_LIGHT_BOTH",...  % 12
      "IIO_MOD_LIGHT_IR",...  % 13
      "IIO_MOD_ROOT_SUM_SQUARED_X_Y",...  % 14
      "IIO_MOD_SUM_SQUARED_X_Y_Z",...  % 15
      "IIO_MOD_LIGHT_CLEAR",...  % 16
      "IIO_MOD_LIGHT_RED",...  % 17
      "IIO_MOD_LIGHT_GREEN",...  % 18
      "IIO_MOD_LIGHT_BLUE",...  % 19
      "IIO_MOD_QUATERNION",...  % 20
      "IIO_MOD_TEMP_AMBIENT",...  % 21
      "IIO_MOD_TEMP_OBJECT",...  % 22
      "IIO_MOD_NORTH_MAGN",...  % 23
      "IIO_MOD_NORTH_TRUE",...  % 24
      "IIO_MOD_NORTH_MAGN_TILT_COMP",...  % 25
      "IIO_MOD_NORTH_TRUE_TILT_COMP",...  % 26
      "IIO_MOD_RUNNING",...  % 27
      "IIO_MOD_JOGGING",...  % 28
      "IIO_MOD_WALKING",...  % 29
      "IIO_MOD_STILL",...  % 30
      "IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z",...  % 31
      "IIO_MOD_I",...  % 32
      "IIO_MOD_Q",...  % 33
      "IIO_MOD_CO2",...  % 34
      "IIO_MOD_VOC",...  % 35
      "IIO_MOD_LIGHT_UV",...  % 36
      "IIO_MOD_LIGHT_DUV",...  % 37
      "IIO_MOD_PM1",...  % 38
      "IIO_MOD_PM2P5",...  % 39
      "IIO_MOD_PM4",...  % 40
      "IIO_MOD_PM10",...  % 41
      "IIO_MOD_ETHANOL",...  % 42
      "IIO_MOD_H2",...  % 43
    ],...
    "MATLABName", "clib.libm2k.iio_modifier", ...
    "Description", "clib.libm2k.iio_modifier    Representation of C++ enumeration iio_modifier." + newline + ...
    "IIO channel modifier", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "r" + newline + ...
    "" + newline + ...
    "In a addition to a type a IIO channel can optionally have a channel modifier" + newline + ...
    "further specifying the data type of of the channel."); % Modify help description values as needed.

%% C++ class |iio_data_format| with MATLAB name |clib.libm2k.iio_data_format|
iio_data_formatDefinition = addClass(libDef, "iio_data_format", "MATLABName", "clib.libm2k.iio_data_format", ...
    "Description", "clib.libm2k.iio_data_format    Representation of C++ class iio_data_format." + newline + ...
    "Contains the format of a data sample.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "e." + newline + ...
    "" + newline + ...
    "The different fields inform about the correct way to convert one sample from" + newline + ...
    "its raw format (as read from / generated by the hardware) to its real-world" + newline + ...
    "value."); % Modify help description values as needed.

%% C++ class constructor for C++ class |iio_data_format|
% C++ Signature: iio_data_format::iio_data_format()
iio_data_formatConstructor1Definition = addConstructor(iio_data_formatDefinition, ...
    "iio_data_format::iio_data_format()", ...
    "Description", "clib.libm2k.iio_data_format.iio_data_format    Constructor of C++ class iio_data_format."); % Modify help description values as needed.
validate(iio_data_formatConstructor1Definition);

%% C++ class constructor for C++ class |iio_data_format|
% C++ Signature: iio_data_format::iio_data_format(iio_data_format const & input1)
iio_data_formatConstructor2Definition = addConstructor(iio_data_formatDefinition, ...
    "iio_data_format::iio_data_format(iio_data_format const & input1)", ...
    "Description", "clib.libm2k.iio_data_format.iio_data_format    Constructor of C++ class iio_data_format."); % Modify help description values as needed.
defineArgument(iio_data_formatConstructor2Definition, "input1", "clib.libm2k.iio_data_format", "input");
validate(iio_data_formatConstructor2Definition);

%% C++ class public data member |length| for C++ class |iio_data_format|
% C++ Signature: unsigned int iio_data_format::length
addProperty(iio_data_formatDefinition, "length", "uint32", ...
    "Description", "uint32    Data member of C++ class iio_data_format." + newline + ...
    "Total length of the sample, in bits"); % Modify help description values as needed.

%% C++ class public data member |bits| for C++ class |iio_data_format|
% C++ Signature: unsigned int iio_data_format::bits
addProperty(iio_data_formatDefinition, "bits", "uint32", ...
    "Description", "uint32    Data member of C++ class iio_data_format." + newline + ...
    "Length of valuable data in the sample, in bits"); % Modify help description values as needed.

%% C++ class public data member |shift| for C++ class |iio_data_format|
% C++ Signature: unsigned int iio_data_format::shift
addProperty(iio_data_formatDefinition, "shift", "uint32", ...
    "Description", "uint32    Data member of C++ class iio_data_format." + newline + ...
    "Right-shift to apply when converting sample"); % Modify help description values as needed.

%% C++ class public data member |is_signed| for C++ class |iio_data_format|
% C++ Signature: bool iio_data_format::is_signed
addProperty(iio_data_formatDefinition, "is_signed", "logical", ...
    "Description", "logical    Data member of C++ class iio_data_format." + newline + ...
    "Contains True if the sample is signed"); % Modify help description values as needed.

%% C++ class public data member |is_fully_defined| for C++ class |iio_data_format|
% C++ Signature: bool iio_data_format::is_fully_defined
addProperty(iio_data_formatDefinition, "is_fully_defined", "logical", ...
    "Description", "logical    Data member of C++ class iio_data_format." + newline + ...
    "Contains True if the sample is fully defined, sign extended, etc."); % Modify help description values as needed.

%% C++ class public data member |is_be| for C++ class |iio_data_format|
% C++ Signature: bool iio_data_format::is_be
addProperty(iio_data_formatDefinition, "is_be", "logical", ...
    "Description", "logical    Data member of C++ class iio_data_format." + newline + ...
    "Contains True if the sample is in big-endian format"); % Modify help description values as needed.

%% C++ class public data member |with_scale| for C++ class |iio_data_format|
% C++ Signature: bool iio_data_format::with_scale
addProperty(iio_data_formatDefinition, "with_scale", "logical", ...
    "Description", "logical    Data member of C++ class iio_data_format." + newline + ...
    "Contains True if the sample should be scaled when converted"); % Modify help description values as needed.

%% C++ class public data member |scale| for C++ class |iio_data_format|
% C++ Signature: double iio_data_format::scale
addProperty(iio_data_formatDefinition, "scale", "double", ...
    "Description", "double    Data member of C++ class iio_data_format." + newline + ...
    "Contains the scale to apply if with_scale is set"); % Modify help description values as needed.

%% C++ class public data member |repeat| for C++ class |iio_data_format|
% C++ Signature: unsigned int iio_data_format::repeat
addProperty(iio_data_formatDefinition, "repeat", "uint32", ...
    "Description", "uint32    Data member of C++ class iio_data_format." + newline + ...
    "Number of times length repeats (added in v0.8)"); % Modify help description values as needed.

%% C++ class |no_device_exception| with MATLAB name |clib.libm2k.no_device_exception|
no_device_exceptionDefinition = addClass(libDef, "no_device_exception", "MATLABName", "clib.libm2k.no_device_exception", ...
    "Description", "clib.libm2k.no_device_exception    Representation of C++ class no_device_exception."); % Modify help description values as needed.

%% C++ class constructor for C++ class |no_device_exception|
% C++ Signature: no_device_exception::no_device_exception(std::string const & what)
no_device_exceptionConstructor1Definition = addConstructor(no_device_exceptionDefinition, ...
    "no_device_exception::no_device_exception(std::string const & what)", ...
    "Description", "clib.libm2k.no_device_exception.no_device_exception    Constructor of C++ class no_device_exception."); % Modify help description values as needed.
defineArgument(no_device_exceptionConstructor1Definition, "what", "string", "input");
validate(no_device_exceptionConstructor1Definition);

%% C++ class constructor for C++ class |no_device_exception|
% C++ Signature: no_device_exception::no_device_exception(char const * what)
%no_device_exceptionConstructor2Definition = addConstructor(no_device_exceptionDefinition, ...
%    "no_device_exception::no_device_exception(char const * what)", ...
%    "Description", "clib.libm2k.no_device_exception.no_device_exception    Constructor of C++ class no_device_exception."); % Modify help description values as needed.
%defineArgument(no_device_exceptionConstructor2Definition, "what", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(no_device_exceptionConstructor2Definition);

%% C++ class constructor for C++ class |no_device_exception|
% C++ Signature: no_device_exception::no_device_exception(no_device_exception const & input1)
no_device_exceptionConstructor3Definition = addConstructor(no_device_exceptionDefinition, ...
    "no_device_exception::no_device_exception(no_device_exception const & input1)", ...
    "Description", "clib.libm2k.no_device_exception.no_device_exception    Constructor of C++ class no_device_exception."); % Modify help description values as needed.
defineArgument(no_device_exceptionConstructor3Definition, "input1", "clib.libm2k.no_device_exception", "input");
validate(no_device_exceptionConstructor3Definition);

%% C++ class |instrument_already_in_use_exception| with MATLAB name |clib.libm2k.instrument_already_in_use_exception|
instrument_already_in_use_exceptionDefinition = addClass(libDef, "instrument_already_in_use_exception", "MATLABName", "clib.libm2k.instrument_already_in_use_exception", ...
    "Description", "clib.libm2k.instrument_already_in_use_exception    Representation of C++ class instrument_already_in_use_exception."); % Modify help description values as needed.

%% C++ class constructor for C++ class |instrument_already_in_use_exception|
% C++ Signature: instrument_already_in_use_exception::instrument_already_in_use_exception(std::string const & what)
instrument_already_in_use_exceptConstructor1Definition = addConstructor(instrument_already_in_use_exceptionDefinition, ...
    "instrument_already_in_use_exception::instrument_already_in_use_exception(std::string const & what)", ...
    "Description", "clib.libm2k.instrument_already_in_use_exception.instrument_already_in_use_exception    Constructor of C++ class instrument_already_in_use_exception."); % Modify help description values as needed.
defineArgument(instrument_already_in_use_exceptConstructor1Definition, "what", "string", "input");
validate(instrument_already_in_use_exceptConstructor1Definition);

%% C++ class constructor for C++ class |instrument_already_in_use_exception|
% C++ Signature: instrument_already_in_use_exception::instrument_already_in_use_exception(char const * what)
%instrument_already_in_use_exceptConstructor2Definition = addConstructor(instrument_already_in_use_exceptionDefinition, ...
%    "instrument_already_in_use_exception::instrument_already_in_use_exception(char const * what)", ...
%    "Description", "clib.libm2k.instrument_already_in_use_exception.instrument_already_in_use_exception    Constructor of C++ class instrument_already_in_use_exception."); % Modify help description values as needed.
%defineArgument(instrument_already_in_use_exceptConstructor2Definition, "what", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(instrument_already_in_use_exceptConstructor2Definition);

%% C++ class constructor for C++ class |instrument_already_in_use_exception|
% C++ Signature: instrument_already_in_use_exception::instrument_already_in_use_exception(instrument_already_in_use_exception const & input1)
instrument_already_in_use_exceptConstructor3Definition = addConstructor(instrument_already_in_use_exceptionDefinition, ...
    "instrument_already_in_use_exception::instrument_already_in_use_exception(instrument_already_in_use_exception const & input1)", ...
    "Description", "clib.libm2k.instrument_already_in_use_exception.instrument_already_in_use_exception    Constructor of C++ class instrument_already_in_use_exception."); % Modify help description values as needed.
defineArgument(instrument_already_in_use_exceptConstructor3Definition, "input1", "clib.libm2k.instrument_already_in_use_exception", "input");
validate(instrument_already_in_use_exceptConstructor3Definition);

%% C++ class |invalid_parameter_exception| with MATLAB name |clib.libm2k.invalid_parameter_exception|
invalid_parameter_exceptionDefinition = addClass(libDef, "invalid_parameter_exception", "MATLABName", "clib.libm2k.invalid_parameter_exception", ...
    "Description", "clib.libm2k.invalid_parameter_exception    Representation of C++ class invalid_parameter_exception."); % Modify help description values as needed.

%% C++ class constructor for C++ class |invalid_parameter_exception|
% C++ Signature: invalid_parameter_exception::invalid_parameter_exception(std::string const & what)
invalid_parameter_exceptionConstructor1Definition = addConstructor(invalid_parameter_exceptionDefinition, ...
    "invalid_parameter_exception::invalid_parameter_exception(std::string const & what)", ...
    "Description", "clib.libm2k.invalid_parameter_exception.invalid_parameter_exception    Constructor of C++ class invalid_parameter_exception."); % Modify help description values as needed.
defineArgument(invalid_parameter_exceptionConstructor1Definition, "what", "string", "input");
validate(invalid_parameter_exceptionConstructor1Definition);

%% C++ class constructor for C++ class |invalid_parameter_exception|
% C++ Signature: invalid_parameter_exception::invalid_parameter_exception(char const * what)
%invalid_parameter_exceptionConstructor2Definition = addConstructor(invalid_parameter_exceptionDefinition, ...
%    "invalid_parameter_exception::invalid_parameter_exception(char const * what)", ...
%    "Description", "clib.libm2k.invalid_parameter_exception.invalid_parameter_exception    Constructor of C++ class invalid_parameter_exception."); % Modify help description values as needed.
%defineArgument(invalid_parameter_exceptionConstructor2Definition, "what", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(invalid_parameter_exceptionConstructor2Definition);

%% C++ class constructor for C++ class |invalid_parameter_exception|
% C++ Signature: invalid_parameter_exception::invalid_parameter_exception(invalid_parameter_exception const & input1)
invalid_parameter_exceptionConstructor3Definition = addConstructor(invalid_parameter_exceptionDefinition, ...
    "invalid_parameter_exception::invalid_parameter_exception(invalid_parameter_exception const & input1)", ...
    "Description", "clib.libm2k.invalid_parameter_exception.invalid_parameter_exception    Constructor of C++ class invalid_parameter_exception."); % Modify help description values as needed.
defineArgument(invalid_parameter_exceptionConstructor3Definition, "input1", "clib.libm2k.invalid_parameter_exception", "input");
validate(invalid_parameter_exceptionConstructor3Definition);

%% C++ class |timeout_exception| with MATLAB name |clib.libm2k.timeout_exception|
timeout_exceptionDefinition = addClass(libDef, "timeout_exception", "MATLABName", "clib.libm2k.timeout_exception", ...
    "Description", "clib.libm2k.timeout_exception    Representation of C++ class timeout_exception."); % Modify help description values as needed.

%% C++ class constructor for C++ class |timeout_exception|
% C++ Signature: timeout_exception::timeout_exception(std::string const & what)
timeout_exceptionConstructor1Definition = addConstructor(timeout_exceptionDefinition, ...
    "timeout_exception::timeout_exception(std::string const & what)", ...
    "Description", "clib.libm2k.timeout_exception.timeout_exception    Constructor of C++ class timeout_exception."); % Modify help description values as needed.
defineArgument(timeout_exceptionConstructor1Definition, "what", "string", "input");
validate(timeout_exceptionConstructor1Definition);

%% C++ class constructor for C++ class |timeout_exception|
% C++ Signature: timeout_exception::timeout_exception(char const * what)
%timeout_exceptionConstructor2Definition = addConstructor(timeout_exceptionDefinition, ...
%    "timeout_exception::timeout_exception(char const * what)", ...
%    "Description", "clib.libm2k.timeout_exception.timeout_exception    Constructor of C++ class timeout_exception."); % Modify help description values as needed.
%defineArgument(timeout_exceptionConstructor2Definition, "what", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(timeout_exceptionConstructor2Definition);

%% C++ class constructor for C++ class |timeout_exception|
% C++ Signature: timeout_exception::timeout_exception(timeout_exception const & input1)
timeout_exceptionConstructor3Definition = addConstructor(timeout_exceptionDefinition, ...
    "timeout_exception::timeout_exception(timeout_exception const & input1)", ...
    "Description", "clib.libm2k.timeout_exception.timeout_exception    Constructor of C++ class timeout_exception."); % Modify help description values as needed.
defineArgument(timeout_exceptionConstructor3Definition, "input1", "clib.libm2k.timeout_exception", "input");
validate(timeout_exceptionConstructor3Definition);

%% C++ function |iio_create_scan_context| with MATLAB name |clib.libm2k.iio_create_scan_context|
% C++ Signature: iio_scan_context * iio_create_scan_context(char const * backend,unsigned int flags)
%iio_create_scan_contextDefinition = addFunction(libDef, ...
%    "iio_scan_context * iio_create_scan_context(char const * backend,unsigned int flags)", ...
%    "MATLABName", "clib.libm2k.iio_create_scan_context", ...
%    "Description", "clib.libm2k.iio_create_scan_context    Representation of C++ function iio_create_scan_context." + newline + ...
%    "Create a scan context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_create_scan_contextDefinition, "backend", <MLTYPE>, "input", <SHAPE>, "Description", "backend A NULL-terminated string containing the backend(s) to use for" + newline + ...
%    "scanning (example: pre version 0.20 :  ""local"", ""ip"", or ""usb""; post version" + newline + ...
%    "0.20 can handle multiple, including ""local:usb:"", ""ip:usb:"", ""local:usb:ip:"")." + newline + ...
%    "If NULL, all the available backends are used."); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_create_scan_contextDefinition, "flags", "uint32", "Description", "flags Unused for now. Set to 0.");
%defineOutput(iio_create_scan_contextDefinition, "RetVal", "clib.libm2k.iio_scan_context", <SHAPE>, "Description", "on success, a pointer to a iio_scan_context structure");
%validate(iio_create_scan_contextDefinition);

%% C++ function |iio_scan_context_destroy| with MATLAB name |clib.libm2k.iio_scan_context_destroy|
% C++ Signature: void iio_scan_context_destroy(iio_scan_context * ctx)
%iio_scan_context_destroyDefinition = addFunction(libDef, ...
%    "void iio_scan_context_destroy(iio_scan_context * ctx)", ...
%    "MATLABName", "clib.libm2k.iio_scan_context_destroy", ...
%    "Description", "clib.libm2k.iio_scan_context_destroy    Representation of C++ function iio_scan_context_destroy." + newline + ...
%    "Destroy the given scan context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_scan_context_destroyDefinition, "ctx", "clib.libm2k.iio_scan_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_scan_context structure");
%validate(iio_scan_context_destroyDefinition);

%% C++ function |iio_context_info_list_free| with MATLAB name |clib.libm2k.iio_context_info_list_free|
% C++ Signature: void iio_context_info_list_free(iio_context_info * * info)
% iio_context_info_list_freeDefinition = addFunction(libDef, ...
%     "void iio_context_info_list_free(iio_context_info * * info)", ...
%     "MATLABName", "clib.libm2k.iio_context_info_list_free", ...
%     "Description", "clib.libm2k.iio_context_info_list_free    Representation of C++ function iio_context_info_list_free." + newline + ...
%     "Free a context info list", ...
%     "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
% defineArgument(iio_context_info_list_freeDefinition, "info", "clib.libm2k.iio_context_info", "output", 1, "Description", "info A pointer to a 'const struct iio_context_info *' typed variable");
% validate(iio_context_info_list_freeDefinition);

%% C++ function |iio_context_info_get_description| with MATLAB name |clib.libm2k.iio_context_info_get_description|
% C++ Signature: char const * iio_context_info_get_description(iio_context_info const * info)
%iio_context_info_get_descriptionDefinition = addFunction(libDef, ...
%    "char const * iio_context_info_get_description(iio_context_info const * info)", ...
%    "MATLABName", "clib.libm2k.iio_context_info_get_description", ...
%    "Description", "clib.libm2k.iio_context_info_get_description    Representation of C++ function iio_context_info_get_description." + newline + ...
%    "Get a description of a discovered context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_info_get_descriptionDefinition, "info", "clib.libm2k.iio_context_info", "input", <SHAPE>, "Description", "info A pointer to an iio_context_info structure");
%defineOutput(iio_context_info_get_descriptionDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "A pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_context_info_get_descriptionDefinition);

%% C++ function |iio_context_info_get_uri| with MATLAB name |clib.libm2k.iio_context_info_get_uri|
% C++ Signature: char const * iio_context_info_get_uri(iio_context_info const * info)
%iio_context_info_get_uriDefinition = addFunction(libDef, ...
%    "char const * iio_context_info_get_uri(iio_context_info const * info)", ...
%    "MATLABName", "clib.libm2k.iio_context_info_get_uri", ...
%    "Description", "clib.libm2k.iio_context_info_get_uri    Representation of C++ function iio_context_info_get_uri." + newline + ...
%    "Get the URI of a discovered context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_info_get_uriDefinition, "info", "clib.libm2k.iio_context_info", "input", <SHAPE>, "Description", "info A pointer to an iio_context_info structure");
%defineOutput(iio_context_info_get_uriDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "A pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_context_info_get_uriDefinition);

%% C++ function |iio_create_scan_block| with MATLAB name |clib.libm2k.iio_create_scan_block|
% C++ Signature: iio_scan_block * iio_create_scan_block(char const * backend,unsigned int flags)
%iio_create_scan_blockDefinition = addFunction(libDef, ...
%    "iio_scan_block * iio_create_scan_block(char const * backend,unsigned int flags)", ...
%    "MATLABName", "clib.libm2k.iio_create_scan_block", ...
%    "Description", "clib.libm2k.iio_create_scan_block    Representation of C++ function iio_create_scan_block." + newline + ...
%    "Create a scan block", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_create_scan_blockDefinition, "backend", <MLTYPE>, "input", <SHAPE>, "Description", "backend A NULL-terminated string containing the backend to use for" + newline + ...
%    "scanning. If NULL, all the available backends are used."); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_create_scan_blockDefinition, "flags", "uint32", "Description", "flags Unused for now. Set to 0.");
%defineOutput(iio_create_scan_blockDefinition, "RetVal", "clib.libm2k.iio_scan_block", <SHAPE>, "Description", "on success, a pointer to a iio_scan_block structure");
%validate(iio_create_scan_blockDefinition);

%% C++ function |iio_scan_block_destroy| with MATLAB name |clib.libm2k.iio_scan_block_destroy|
% C++ Signature: void iio_scan_block_destroy(iio_scan_block * blk)
%iio_scan_block_destroyDefinition = addFunction(libDef, ...
%    "void iio_scan_block_destroy(iio_scan_block * blk)", ...
%    "MATLABName", "clib.libm2k.iio_scan_block_destroy", ...
%    "Description", "clib.libm2k.iio_scan_block_destroy    Representation of C++ function iio_scan_block_destroy." + newline + ...
%    "Destroy the given scan block", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_scan_block_destroyDefinition, "blk", "clib.libm2k.iio_scan_block", "input", <SHAPE>, "Description", "blk A pointer to an iio_scan_block structure");
%validate(iio_scan_block_destroyDefinition);

%% C++ function |iio_scan_block_scan| with MATLAB name |clib.libm2k.iio_scan_block_scan|
% C++ Signature: ssize_t iio_scan_block_scan(iio_scan_block * blk)
%iio_scan_block_scanDefinition = addFunction(libDef, ...
%    "ssize_t iio_scan_block_scan(iio_scan_block * blk)", ...
%    "MATLABName", "clib.libm2k.iio_scan_block_scan", ...
%    "Description", "clib.libm2k.iio_scan_block_scan    Representation of C++ function iio_scan_block_scan." + newline + ...
%    "Enumerate available contexts via scan block", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_scan_block_scanDefinition, "blk", "clib.libm2k.iio_scan_block", "input", <SHAPE>, "Description", "blk A pointer to a iio_scan_block structure.");
%defineOutput(iio_scan_block_scanDefinition, "RetVal", "int64", "Description", "s On success, the number of contexts found.");
%validate(iio_scan_block_scanDefinition);

%% C++ function |iio_scan_block_get_info| with MATLAB name |clib.libm2k.iio_scan_block_get_info|
% C++ Signature: iio_context_info * iio_scan_block_get_info(iio_scan_block * blk,unsigned int index)
%iio_scan_block_get_infoDefinition = addFunction(libDef, ...
%    "iio_context_info * iio_scan_block_get_info(iio_scan_block * blk,unsigned int index)", ...
%    "MATLABName", "clib.libm2k.iio_scan_block_get_info", ...
%    "Description", "clib.libm2k.iio_scan_block_get_info    Representation of C++ function iio_scan_block_get_info." + newline + ...
%    "Get the iio_context_info for a particular context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_scan_block_get_infoDefinition, "blk", "clib.libm2k.iio_scan_block", "input", <SHAPE>, "Description", "blk A pointer to an iio_scan_block structure");
%defineArgument(iio_scan_block_get_infoDefinition, "index", "uint32", "Description", "index The index corresponding to the context.");
%defineOutput(iio_scan_block_get_infoDefinition, "RetVal", "clib.libm2k.iio_context_info", <SHAPE>, "Description", "A pointer to the iio_context_info for the context");
%validate(iio_scan_block_get_infoDefinition);

%% C++ function |iio_library_get_version| with MATLAB name |clib.libm2k.iio_library_get_version|
% C++ Signature: void iio_library_get_version(unsigned int * major,unsigned int * minor,char [8] git_tag)
%iio_library_get_versionDefinition = addFunction(libDef, ...
%    "void iio_library_get_version(unsigned int * major,unsigned int * minor,char [8] git_tag)", ...
%    "MATLABName", "clib.libm2k.iio_library_get_version", ...
%    "Description", "clib.libm2k.iio_library_get_version    Representation of C++ function iio_library_get_version." + newline + ...
%    "Get the version of the libiio library", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_library_get_versionDefinition, "major", "clib.array.libm2k.UnsignedInt", "input", <SHAPE>, "Description", "major A pointer to an unsigned integer (NULL accepted)"); % '<MLTYPE>' can be clib.array.libm2k.UnsignedInt, or uint32
%defineArgument(iio_library_get_versionDefinition, "minor", "clib.array.libm2k.UnsignedInt", "input", <SHAPE>, "Description", "minor A pointer to an unsigned integer (NULL accepted)"); % '<MLTYPE>' can be clib.array.libm2k.UnsignedInt, or uint32
%defineArgument(iio_library_get_versionDefinition, "git_tag", "clib.array.libm2k.Char", "input", [8], "Description", "git_tag A pointer to a 8-characters buffer (NULL accepted)"); % '<MLTYPE>' can be clib.array.libm2k.Char, or int8
%validate(iio_library_get_versionDefinition);

%% C++ function |iio_strerror| with MATLAB name |clib.libm2k.iio_strerror|
% C++ Signature: void iio_strerror(int err,char * dst,size_t len)
%iio_strerrorDefinition = addFunction(libDef, ...
%    "void iio_strerror(int err,char * dst,size_t len)", ...
%    "MATLABName", "clib.libm2k.iio_strerror", ...
%    "Description", "clib.libm2k.iio_strerror    Representation of C++ function iio_strerror." + newline + ...
%    "Get a string description of an error code", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_strerrorDefinition, "err", "int32", "Description", "err The error code");
%defineArgument(iio_strerrorDefinition, "dst", <MLTYPE>, "input", <SHAPE>, "Description", "dst A pointer to the memory area where the NULL-terminated string" + newline + ...
%    "corresponding to the error message will be stored"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_strerrorDefinition, "len", "uint64", "Description", "len The available length of the memory area, in bytes");
%validate(iio_strerrorDefinition);

%% C++ function |iio_has_backend| with MATLAB name |clib.libm2k.iio_has_backend|
% C++ Signature: bool iio_has_backend(char const * backend)
%iio_has_backendDefinition = addFunction(libDef, ...
%    "bool iio_has_backend(char const * backend)", ...
%    "MATLABName", "clib.libm2k.iio_has_backend", ...
%    "Description", "clib.libm2k.iio_has_backend    Representation of C++ function iio_has_backend." + newline + ...
%    "Check if the specified backend is available", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_has_backendDefinition, "backend", <MLTYPE>, "input", <SHAPE>, "Description", "backend The name of the backend to query"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_has_backendDefinition, "RetVal", "logical", "Description", "True if the backend is available, false otherwise");
%validate(iio_has_backendDefinition);

%% C++ function |iio_get_backends_count| with MATLAB name |clib.libm2k.iio_get_backends_count|
% C++ Signature: unsigned int iio_get_backends_count()
% iio_get_backends_countDefinition = addFunction(libDef, ...
%     "unsigned int iio_get_backends_count()", ...
%     "MATLABName", "clib.libm2k.iio_get_backends_count", ...
%     "Description", "clib.libm2k.iio_get_backends_count    Representation of C++ function iio_get_backends_count." + newline + ...
%     "Get the number of available backends", ...
%     "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
% defineOutput(iio_get_backends_countDefinition, "RetVal", "uint32", "Description", "The number of available backends");
% validate(iio_get_backends_countDefinition);

%% C++ function |iio_get_backend| with MATLAB name |clib.libm2k.iio_get_backend|
% C++ Signature: char const * iio_get_backend(unsigned int index)
%iio_get_backendDefinition = addFunction(libDef, ...
%    "char const * iio_get_backend(unsigned int index)", ...
%    "MATLABName", "clib.libm2k.iio_get_backend", ...
%    "Description", "clib.libm2k.iio_get_backend    Representation of C++ function iio_get_backend." + newline + ...
%    "Retrieve the name of a given backend", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_get_backendDefinition, "index", "uint32", "Description", "index The index corresponding to the attribute");
%defineOutput(iio_get_backendDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_get_backendDefinition);

%% C++ function |iio_create_default_context| with MATLAB name |clib.libm2k.iio_create_default_context|
% C++ Signature: iio_context * iio_create_default_context()
%iio_create_default_contextDefinition = addFunction(libDef, ...
%    "iio_context * iio_create_default_context()", ...
%    "MATLABName", "clib.libm2k.iio_create_default_context", ...
%    "Description", "clib.libm2k.iio_create_default_context    Representation of C++ function iio_create_default_context." + newline + ...
%    "Create a context from local or remote IIO devices", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineOutput(iio_create_default_contextDefinition, "RetVal", "clib.libm2k.iio_context", <SHAPE>, "Description", "On success, A pointer to an iio_context structure");
%validate(iio_create_default_contextDefinition);

%% C++ function |iio_create_local_context| with MATLAB name |clib.libm2k.iio_create_local_context|
% C++ Signature: iio_context * iio_create_local_context()
%iio_create_local_contextDefinition = addFunction(libDef, ...
%    "iio_context * iio_create_local_context()", ...
%    "MATLABName", "clib.libm2k.iio_create_local_context", ...
%    "Description", "clib.libm2k.iio_create_local_context    Representation of C++ function iio_create_local_context." + newline + ...
%    "Create a context from local IIO devices (Linux only)", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineOutput(iio_create_local_contextDefinition, "RetVal", "clib.libm2k.iio_context", <SHAPE>, "Description", "On success, A pointer to an iio_context structure");
%validate(iio_create_local_contextDefinition);

%% C++ function |iio_create_xml_context| with MATLAB name |clib.libm2k.iio_create_xml_context|
% C++ Signature: iio_context * iio_create_xml_context(char const * xml_file)
%iio_create_xml_contextDefinition = addFunction(libDef, ...
%    "iio_context * iio_create_xml_context(char const * xml_file)", ...
%    "MATLABName", "clib.libm2k.iio_create_xml_context", ...
%    "Description", "clib.libm2k.iio_create_xml_context    Representation of C++ function iio_create_xml_context." + newline + ...
%    "Create a context from a XML file", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_create_xml_contextDefinition, "xml_file", <MLTYPE>, "input", <SHAPE>, "Description", "xml_file Path to the XML file to open"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_create_xml_contextDefinition, "RetVal", "clib.libm2k.iio_context", <SHAPE>, "Description", "On success, A pointer to an iio_context structure");
%validate(iio_create_xml_contextDefinition);

%% C++ function |iio_create_xml_context_mem| with MATLAB name |clib.libm2k.iio_create_xml_context_mem|
% C++ Signature: iio_context * iio_create_xml_context_mem(char const * xml,size_t len)
%iio_create_xml_context_memDefinition = addFunction(libDef, ...
%    "iio_context * iio_create_xml_context_mem(char const * xml,size_t len)", ...
%    "MATLABName", "clib.libm2k.iio_create_xml_context_mem", ...
%    "Description", "clib.libm2k.iio_create_xml_context_mem    Representation of C++ function iio_create_xml_context_mem." + newline + ...
%    "Create a context from XML data in memory", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_create_xml_context_memDefinition, "xml", <MLTYPE>, "input", <SHAPE>, "Description", "xml Pointer to the XML data in memory"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_create_xml_context_memDefinition, "len", "uint64", "Description", "len Length of the XML string in memory (excluding the final \0)");
%defineOutput(iio_create_xml_context_memDefinition, "RetVal", "clib.libm2k.iio_context", <SHAPE>, "Description", "On success, A pointer to an iio_context structure");
%validate(iio_create_xml_context_memDefinition);

%% C++ function |iio_create_network_context| with MATLAB name |clib.libm2k.iio_create_network_context|
% C++ Signature: iio_context * iio_create_network_context(char const * host)
%iio_create_network_contextDefinition = addFunction(libDef, ...
%    "iio_context * iio_create_network_context(char const * host)", ...
%    "MATLABName", "clib.libm2k.iio_create_network_context", ...
%    "Description", "clib.libm2k.iio_create_network_context    Representation of C++ function iio_create_network_context." + newline + ...
%    "Create a context from the network", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_create_network_contextDefinition, "host", <MLTYPE>, "input", <SHAPE>, "Description", "host Hostname, IPv4 or IPv6 address where the IIO Daemon is running"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_create_network_contextDefinition, "RetVal", "clib.libm2k.iio_context", <SHAPE>, "Description", "On success, a pointer to an iio_context structure");
%validate(iio_create_network_contextDefinition);

%% C++ function |iio_create_context_from_uri| with MATLAB name |clib.libm2k.iio_create_context_from_uri|
% C++ Signature: iio_context * iio_create_context_from_uri(char const * uri)
%iio_create_context_from_uriDefinition = addFunction(libDef, ...
%    "iio_context * iio_create_context_from_uri(char const * uri)", ...
%    "MATLABName", "clib.libm2k.iio_create_context_from_uri", ...
%    "Description", "clib.libm2k.iio_create_context_from_uri    Representation of C++ function iio_create_context_from_uri." + newline + ...
%    "Create a context from a URI description", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_create_context_from_uriDefinition, "uri", <MLTYPE>, "input", <SHAPE>, "Description", "uri A URI describing the context location"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_create_context_from_uriDefinition, "RetVal", "clib.libm2k.iio_context", <SHAPE>, "Description", "On success, a pointer to a iio_context structure");
%validate(iio_create_context_from_uriDefinition);

%% C++ function |iio_context_clone| with MATLAB name |clib.libm2k.iio_context_clone|
% C++ Signature: iio_context * iio_context_clone(iio_context const * ctx)
%iio_context_cloneDefinition = addFunction(libDef, ...
%    "iio_context * iio_context_clone(iio_context const * ctx)", ...
%    "MATLABName", "clib.libm2k.iio_context_clone", ...
%    "Description", "clib.libm2k.iio_context_clone    Representation of C++ function iio_context_clone." + newline + ...
%    "Duplicate a pre-existing IIO context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_cloneDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineOutput(iio_context_cloneDefinition, "RetVal", "clib.libm2k.iio_context", <SHAPE>, "Description", "On success, A pointer to an iio_context structure");
%validate(iio_context_cloneDefinition);

%% C++ function |iio_context_destroy| with MATLAB name |clib.libm2k.iio_context_destroy|
% C++ Signature: void iio_context_destroy(iio_context * ctx)
%iio_context_destroyDefinition = addFunction(libDef, ...
%    "void iio_context_destroy(iio_context * ctx)", ...
%    "MATLABName", "clib.libm2k.iio_context_destroy", ...
%    "Description", "clib.libm2k.iio_context_destroy    Representation of C++ function iio_context_destroy." + newline + ...
%    "Destroy the given context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_destroyDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%validate(iio_context_destroyDefinition);

%% C++ function |iio_context_get_version| with MATLAB name |clib.libm2k.iio_context_get_version|
% C++ Signature: int iio_context_get_version(iio_context const * ctx,unsigned int * major,unsigned int * minor,char [8] git_tag)
%iio_context_get_versionDefinition = addFunction(libDef, ...
%    "int iio_context_get_version(iio_context const * ctx,unsigned int * major,unsigned int * minor,char [8] git_tag)", ...
%    "MATLABName", "clib.libm2k.iio_context_get_version", ...
%    "Description", "clib.libm2k.iio_context_get_version    Representation of C++ function iio_context_get_version." + newline + ...
%    "Get the version of the backend in use", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_get_versionDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineArgument(iio_context_get_versionDefinition, "major", "clib.array.libm2k.UnsignedInt", "input", <SHAPE>, "Description", "major A pointer to an unsigned integer (NULL accepted)"); % '<MLTYPE>' can be clib.array.libm2k.UnsignedInt, or uint32
%defineArgument(iio_context_get_versionDefinition, "minor", "clib.array.libm2k.UnsignedInt", "input", <SHAPE>, "Description", "minor A pointer to an unsigned integer (NULL accepted)"); % '<MLTYPE>' can be clib.array.libm2k.UnsignedInt, or uint32
%defineArgument(iio_context_get_versionDefinition, "git_tag", "clib.array.libm2k.Char", "input", [8], "Description", "git_tag A pointer to a 8-characters buffer (NULL accepted)"); % '<MLTYPE>' can be clib.array.libm2k.Char, or int8
%defineOutput(iio_context_get_versionDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_context_get_versionDefinition);

%% C++ function |iio_context_get_xml| with MATLAB name |clib.libm2k.iio_context_get_xml|
% C++ Signature: char const * iio_context_get_xml(iio_context const * ctx)
%iio_context_get_xmlDefinition = addFunction(libDef, ...
%    "char const * iio_context_get_xml(iio_context const * ctx)", ...
%    "MATLABName", "clib.libm2k.iio_context_get_xml", ...
%    "Description", "clib.libm2k.iio_context_get_xml    Representation of C++ function iio_context_get_xml." + newline + ...
%    "Obtain a XML representation of the given context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_get_xmlDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineOutput(iio_context_get_xmlDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "A pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_context_get_xmlDefinition);

%% C++ function |iio_context_get_name| with MATLAB name |clib.libm2k.iio_context_get_name|
% C++ Signature: char const * iio_context_get_name(iio_context const * ctx)
%iio_context_get_nameDefinition = addFunction(libDef, ...
%    "char const * iio_context_get_name(iio_context const * ctx)", ...
%    "MATLABName", "clib.libm2k.iio_context_get_name", ...
%    "Description", "clib.libm2k.iio_context_get_name    Representation of C++ function iio_context_get_name." + newline + ...
%    "Get the name of the given context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_get_nameDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineOutput(iio_context_get_nameDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "A pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_context_get_nameDefinition);

%% C++ function |iio_context_get_description| with MATLAB name |clib.libm2k.iio_context_get_description|
% C++ Signature: char const * iio_context_get_description(iio_context const * ctx)
%iio_context_get_descriptionDefinition = addFunction(libDef, ...
%    "char const * iio_context_get_description(iio_context const * ctx)", ...
%    "MATLABName", "clib.libm2k.iio_context_get_description", ...
%    "Description", "clib.libm2k.iio_context_get_description    Representation of C++ function iio_context_get_description." + newline + ...
%    "Get a description of the given context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_get_descriptionDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineOutput(iio_context_get_descriptionDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "A pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_context_get_descriptionDefinition);

%% C++ function |iio_context_get_attrs_count| with MATLAB name |clib.libm2k.iio_context_get_attrs_count|
% C++ Signature: unsigned int iio_context_get_attrs_count(iio_context const * ctx)
%iio_context_get_attrs_countDefinition = addFunction(libDef, ...
%    "unsigned int iio_context_get_attrs_count(iio_context const * ctx)", ...
%    "MATLABName", "clib.libm2k.iio_context_get_attrs_count", ...
%    "Description", "clib.libm2k.iio_context_get_attrs_count    Representation of C++ function iio_context_get_attrs_count." + newline + ...
%    "Get the number of context-specific attributes", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_get_attrs_countDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineOutput(iio_context_get_attrs_countDefinition, "RetVal", "uint32", "Description", "The number of context-specific attributes");
%validate(iio_context_get_attrs_countDefinition);

%% C++ function |iio_context_get_attr_value| with MATLAB name |clib.libm2k.iio_context_get_attr_value|
% C++ Signature: char const * iio_context_get_attr_value(iio_context const * ctx,char const * name)
%iio_context_get_attr_valueDefinition = addFunction(libDef, ...
%    "char const * iio_context_get_attr_value(iio_context const * ctx,char const * name)", ...
%    "MATLABName", "clib.libm2k.iio_context_get_attr_value", ...
%    "Description", "clib.libm2k.iio_context_get_attr_value    Representation of C++ function iio_context_get_attr_value." + newline + ...
%    "Retrieve the value of a context-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_get_attr_valueDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineArgument(iio_context_get_attr_valueDefinition, "name", <MLTYPE>, "input", <SHAPE>, "Description", "name The name of the context attribute to read"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_context_get_attr_valueDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_context_get_attr_valueDefinition);

%% C++ function |iio_context_get_devices_count| with MATLAB name |clib.libm2k.iio_context_get_devices_count|
% C++ Signature: unsigned int iio_context_get_devices_count(iio_context const * ctx)
%iio_context_get_devices_countDefinition = addFunction(libDef, ...
%    "unsigned int iio_context_get_devices_count(iio_context const * ctx)", ...
%    "MATLABName", "clib.libm2k.iio_context_get_devices_count", ...
%    "Description", "clib.libm2k.iio_context_get_devices_count    Representation of C++ function iio_context_get_devices_count." + newline + ...
%    "Enumerate the devices found in the given context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_get_devices_countDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineOutput(iio_context_get_devices_countDefinition, "RetVal", "uint32", "Description", "The number of devices found");
%validate(iio_context_get_devices_countDefinition);

%% C++ function |iio_context_get_device| with MATLAB name |clib.libm2k.iio_context_get_device|
% C++ Signature: iio_device * iio_context_get_device(iio_context const * ctx,unsigned int index)
%iio_context_get_deviceDefinition = addFunction(libDef, ...
%    "iio_device * iio_context_get_device(iio_context const * ctx,unsigned int index)", ...
%    "MATLABName", "clib.libm2k.iio_context_get_device", ...
%    "Description", "clib.libm2k.iio_context_get_device    Representation of C++ function iio_context_get_device." + newline + ...
%    "Get the device present at the given index", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_get_deviceDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineArgument(iio_context_get_deviceDefinition, "index", "uint32", "Description", "index The index corresponding to the device");
%defineOutput(iio_context_get_deviceDefinition, "RetVal", "clib.libm2k.iio_device", <SHAPE>, "Description", "On success, a pointer to an iio_device structure");
%validate(iio_context_get_deviceDefinition);

%% C++ function |iio_context_find_device| with MATLAB name |clib.libm2k.iio_context_find_device|
% C++ Signature: iio_device * iio_context_find_device(iio_context const * ctx,char const * name)
%iio_context_find_deviceDefinition = addFunction(libDef, ...
%    "iio_device * iio_context_find_device(iio_context const * ctx,char const * name)", ...
%    "MATLABName", "clib.libm2k.iio_context_find_device", ...
%    "Description", "clib.libm2k.iio_context_find_device    Representation of C++ function iio_context_find_device." + newline + ...
%    "Try to find a device structure by its name of ID", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_find_deviceDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineArgument(iio_context_find_deviceDefinition, "name", <MLTYPE>, "input", <SHAPE>, "Description", "name A NULL-terminated string corresponding to the name or the ID of" + newline + ...
%    "the device to search for"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_context_find_deviceDefinition, "RetVal", "clib.libm2k.iio_device", <SHAPE>, "Description", "On success, a pointer to an iio_device structure");
%validate(iio_context_find_deviceDefinition);

%% C++ function |iio_context_set_timeout| with MATLAB name |clib.libm2k.iio_context_set_timeout|
% C++ Signature: int iio_context_set_timeout(iio_context * ctx,unsigned int timeout_ms)
%iio_context_set_timeoutDefinition = addFunction(libDef, ...
%    "int iio_context_set_timeout(iio_context * ctx,unsigned int timeout_ms)", ...
%    "MATLABName", "clib.libm2k.iio_context_set_timeout", ...
%    "Description", "clib.libm2k.iio_context_set_timeout    Representation of C++ function iio_context_set_timeout." + newline + ...
%    "Set a timeout for I/O operations", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_context_set_timeoutDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineArgument(iio_context_set_timeoutDefinition, "timeout_ms", "uint32", "Description", "timeout_ms A positive integer representing the time in milliseconds" + newline + ...
%    "after which a timeout occurs. A value of 0 is used to specify that no" + newline + ...
%    "timeout should occur.");
%defineOutput(iio_context_set_timeoutDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_context_set_timeoutDefinition);

%% C++ function |iio_device_get_context| with MATLAB name |clib.libm2k.iio_device_get_context|
% C++ Signature: iio_context const * iio_device_get_context(iio_device const * dev)
%iio_device_get_contextDefinition = addFunction(libDef, ...
%    "iio_context const * iio_device_get_context(iio_device const * dev)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_context", ...
%    "Description", "clib.libm2k.iio_device_get_context    Representation of C++ function iio_device_get_context." + newline + ...
%    "Retrieve a pointer to the iio_context structure", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_contextDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineOutput(iio_device_get_contextDefinition, "RetVal", "clib.libm2k.iio_context", <SHAPE>, "Description", "A pointer to an iio_context structure");
%validate(iio_device_get_contextDefinition);

%% C++ function |iio_device_get_id| with MATLAB name |clib.libm2k.iio_device_get_id|
% C++ Signature: char const * iio_device_get_id(iio_device const * dev)
%iio_device_get_idDefinition = addFunction(libDef, ...
%    "char const * iio_device_get_id(iio_device const * dev)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_id", ...
%    "Description", "clib.libm2k.iio_device_get_id    Representation of C++ function iio_device_get_id." + newline + ...
%    "Retrieve the device ID (e.g. <b><i>iio:device0</i></b>)", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_idDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineOutput(iio_device_get_idDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "A pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_device_get_idDefinition);

%% C++ function |iio_device_get_name| with MATLAB name |clib.libm2k.iio_device_get_name|
% C++ Signature: char const * iio_device_get_name(iio_device const * dev)
%iio_device_get_nameDefinition = addFunction(libDef, ...
%    "char const * iio_device_get_name(iio_device const * dev)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_name", ...
%    "Description", "clib.libm2k.iio_device_get_name    Representation of C++ function iio_device_get_name." + newline + ...
%    "Retrieve the device name (e.g. <b><i>xadc</i></b>)", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_nameDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineOutput(iio_device_get_nameDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "A pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_device_get_nameDefinition);

%% C++ function |iio_device_get_channels_count| with MATLAB name |clib.libm2k.iio_device_get_channels_count|
% C++ Signature: unsigned int iio_device_get_channels_count(iio_device const * dev)
%iio_device_get_channels_countDefinition = addFunction(libDef, ...
%    "unsigned int iio_device_get_channels_count(iio_device const * dev)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_channels_count", ...
%    "Description", "clib.libm2k.iio_device_get_channels_count    Representation of C++ function iio_device_get_channels_count." + newline + ...
%    "Enumerate the channels of the given device", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_channels_countDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineOutput(iio_device_get_channels_countDefinition, "RetVal", "uint32", "Description", "The number of channels found");
%validate(iio_device_get_channels_countDefinition);

%% C++ function |iio_device_get_attrs_count| with MATLAB name |clib.libm2k.iio_device_get_attrs_count|
% C++ Signature: unsigned int iio_device_get_attrs_count(iio_device const * dev)
%iio_device_get_attrs_countDefinition = addFunction(libDef, ...
%    "unsigned int iio_device_get_attrs_count(iio_device const * dev)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_attrs_count", ...
%    "Description", "clib.libm2k.iio_device_get_attrs_count    Representation of C++ function iio_device_get_attrs_count." + newline + ...
%    "Enumerate the device-specific attributes of the given device", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_attrs_countDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineOutput(iio_device_get_attrs_countDefinition, "RetVal", "uint32", "Description", "The number of device-specific attributes found");
%validate(iio_device_get_attrs_countDefinition);

%% C++ function |iio_device_get_buffer_attrs_count| with MATLAB name |clib.libm2k.iio_device_get_buffer_attrs_count|
% C++ Signature: unsigned int iio_device_get_buffer_attrs_count(iio_device const * dev)
%iio_device_get_buffer_attrs_countDefinition = addFunction(libDef, ...
%    "unsigned int iio_device_get_buffer_attrs_count(iio_device const * dev)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_buffer_attrs_count", ...
%    "Description", "clib.libm2k.iio_device_get_buffer_attrs_count    Representation of C++ function iio_device_get_buffer_attrs_count." + newline + ...
%    "Enumerate the buffer-specific attributes of the given device", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_buffer_attrs_countDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineOutput(iio_device_get_buffer_attrs_countDefinition, "RetVal", "uint32", "Description", "The number of buffer-specific attributes found");
%validate(iio_device_get_buffer_attrs_countDefinition);

%% C++ function |iio_device_get_channel| with MATLAB name |clib.libm2k.iio_device_get_channel|
% C++ Signature: iio_channel * iio_device_get_channel(iio_device const * dev,unsigned int index)
%iio_device_get_channelDefinition = addFunction(libDef, ...
%    "iio_channel * iio_device_get_channel(iio_device const * dev,unsigned int index)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_channel", ...
%    "Description", "clib.libm2k.iio_device_get_channel    Representation of C++ function iio_device_get_channel." + newline + ...
%    "Get the channel present at the given index", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_channelDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_get_channelDefinition, "index", "uint32", "Description", "index The index corresponding to the channel");
%defineOutput(iio_device_get_channelDefinition, "RetVal", "clib.libm2k.iio_channel", <SHAPE>, "Description", "On success, a pointer to an iio_channel structure");
%validate(iio_device_get_channelDefinition);

%% C++ function |iio_device_get_attr| with MATLAB name |clib.libm2k.iio_device_get_attr|
% C++ Signature: char const * iio_device_get_attr(iio_device const * dev,unsigned int index)
%iio_device_get_attrDefinition = addFunction(libDef, ...
%    "char const * iio_device_get_attr(iio_device const * dev,unsigned int index)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_attr", ...
%    "Description", "clib.libm2k.iio_device_get_attr    Representation of C++ function iio_device_get_attr." + newline + ...
%    "Get the device-specific attribute present at the given index", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_attrDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_get_attrDefinition, "index", "uint32", "Description", "index The index corresponding to the attribute");
%defineOutput(iio_device_get_attrDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_device_get_attrDefinition);

%% C++ function |iio_device_get_buffer_attr| with MATLAB name |clib.libm2k.iio_device_get_buffer_attr|
% C++ Signature: char const * iio_device_get_buffer_attr(iio_device const * dev,unsigned int index)
%iio_device_get_buffer_attrDefinition = addFunction(libDef, ...
%    "char const * iio_device_get_buffer_attr(iio_device const * dev,unsigned int index)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_buffer_attr", ...
%    "Description", "clib.libm2k.iio_device_get_buffer_attr    Representation of C++ function iio_device_get_buffer_attr." + newline + ...
%    "Get the buffer-specific attribute present at the given index", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_buffer_attrDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_get_buffer_attrDefinition, "index", "uint32", "Description", "index The index corresponding to the attribute");
%defineOutput(iio_device_get_buffer_attrDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_device_get_buffer_attrDefinition);

%% C++ function |iio_device_find_channel| with MATLAB name |clib.libm2k.iio_device_find_channel|
% C++ Signature: iio_channel * iio_device_find_channel(iio_device const * dev,char const * name,bool output)
%iio_device_find_channelDefinition = addFunction(libDef, ...
%    "iio_channel * iio_device_find_channel(iio_device const * dev,char const * name,bool output)", ...
%    "MATLABName", "clib.libm2k.iio_device_find_channel", ...
%    "Description", "clib.libm2k.iio_device_find_channel    Representation of C++ function iio_device_find_channel." + newline + ...
%    "Try to find a channel structure by its name of ID", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_find_channelDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_find_channelDefinition, "name", <MLTYPE>, "input", <SHAPE>, "Description", "name A NULL-terminated string corresponding to the name or the ID of" + newline + ...
%    "the channel to search for"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_find_channelDefinition, "output", "logical", "Description", "output True if the searched channel is output, False otherwise");
%defineOutput(iio_device_find_channelDefinition, "RetVal", "clib.libm2k.iio_channel", <SHAPE>, "Description", "On success, a pointer to an iio_channel structure");
%validate(iio_device_find_channelDefinition);

%% C++ function |iio_device_find_attr| with MATLAB name |clib.libm2k.iio_device_find_attr|
% C++ Signature: char const * iio_device_find_attr(iio_device const * dev,char const * name)
%iio_device_find_attrDefinition = addFunction(libDef, ...
%    "char const * iio_device_find_attr(iio_device const * dev,char const * name)", ...
%    "MATLABName", "clib.libm2k.iio_device_find_attr", ...
%    "Description", "clib.libm2k.iio_device_find_attr    Representation of C++ function iio_device_find_attr." + newline + ...
%    "Try to find a device-specific attribute by its name", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_find_attrDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_find_attrDefinition, "name", <MLTYPE>, "input", <SHAPE>, "Description", "name A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_device_find_attrDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_device_find_attrDefinition);

%% C++ function |iio_device_find_buffer_attr| with MATLAB name |clib.libm2k.iio_device_find_buffer_attr|
% C++ Signature: char const * iio_device_find_buffer_attr(iio_device const * dev,char const * name)
%iio_device_find_buffer_attrDefinition = addFunction(libDef, ...
%    "char const * iio_device_find_buffer_attr(iio_device const * dev,char const * name)", ...
%    "MATLABName", "clib.libm2k.iio_device_find_buffer_attr", ...
%    "Description", "clib.libm2k.iio_device_find_buffer_attr    Representation of C++ function iio_device_find_buffer_attr." + newline + ...
%    "Try to find a buffer-specific attribute by its name", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_find_buffer_attrDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_find_buffer_attrDefinition, "name", <MLTYPE>, "input", <SHAPE>, "Description", "name A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_device_find_buffer_attrDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_device_find_buffer_attrDefinition);

%% C++ function |iio_device_attr_read| with MATLAB name |clib.libm2k.iio_device_attr_read|
% C++ Signature: ssize_t iio_device_attr_read(iio_device const * dev,char const * attr,char * dst,size_t len)
%iio_device_attr_readDefinition = addFunction(libDef, ...
%    "ssize_t iio_device_attr_read(iio_device const * dev,char const * attr,char * dst,size_t len)", ...
%    "MATLABName", "clib.libm2k.iio_device_attr_read", ...
%    "Description", "clib.libm2k.iio_device_attr_read    Representation of C++ function iio_device_attr_read." + newline + ...
%    "Read the content of the given device-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_attr_readDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_attr_readDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_attr_readDefinition, "dst", <MLTYPE>, "input", <SHAPE>, "Description", "dst A pointer to the memory area where the NULL-terminated string" + newline + ...
%    "corresponding to the value read will be stored"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_attr_readDefinition, "len", "uint64", "Description", "len The available length of the memory area, in bytes");
%defineOutput(iio_device_attr_readDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written to the buffer");
%validate(iio_device_attr_readDefinition);

%% C++ function |iio_device_attr_read_bool| with MATLAB name |clib.libm2k.iio_device_attr_read_bool|
% C++ Signature: int iio_device_attr_read_bool(iio_device const * dev,char const * attr,bool * val)
%iio_device_attr_read_boolDefinition = addFunction(libDef, ...
%    "int iio_device_attr_read_bool(iio_device const * dev,char const * attr,bool * val)", ...
%    "MATLABName", "clib.libm2k.iio_device_attr_read_bool", ...
%    "Description", "clib.libm2k.iio_device_attr_read_bool    Representation of C++ function iio_device_attr_read_bool." + newline + ...
%    "Read the content of the given device-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_attr_read_boolDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_attr_read_boolDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_attr_read_boolDefinition, "val", "clib.array.libm2k.Bool", "input", <SHAPE>, "Description", "val A pointer to a bool variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.Bool, or logical
%defineOutput(iio_device_attr_read_boolDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_attr_read_boolDefinition);

%% C++ function |iio_device_attr_read_longlong| with MATLAB name |clib.libm2k.iio_device_attr_read_longlong|
% C++ Signature: int iio_device_attr_read_longlong(iio_device const * dev,char const * attr,long long * val)
%iio_device_attr_read_longlongDefinition = addFunction(libDef, ...
%    "int iio_device_attr_read_longlong(iio_device const * dev,char const * attr,long long * val)", ...
%    "MATLABName", "clib.libm2k.iio_device_attr_read_longlong", ...
%    "Description", "clib.libm2k.iio_device_attr_read_longlong    Representation of C++ function iio_device_attr_read_longlong." + newline + ...
%    "Read the content of the given device-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_attr_read_longlongDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_attr_read_longlongDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_attr_read_longlongDefinition, "val", "clib.array.libm2k.LongLong", "input", <SHAPE>, "Description", "val A pointer to a long long variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.LongLong, or int64
%defineOutput(iio_device_attr_read_longlongDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_attr_read_longlongDefinition);

%% C++ function |iio_device_attr_read_double| with MATLAB name |clib.libm2k.iio_device_attr_read_double|
% C++ Signature: int iio_device_attr_read_double(iio_device const * dev,char const * attr,double * val)
%iio_device_attr_read_doubleDefinition = addFunction(libDef, ...
%    "int iio_device_attr_read_double(iio_device const * dev,char const * attr,double * val)", ...
%    "MATLABName", "clib.libm2k.iio_device_attr_read_double", ...
%    "Description", "clib.libm2k.iio_device_attr_read_double    Representation of C++ function iio_device_attr_read_double." + newline + ...
%    "Read the content of the given device-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_attr_read_doubleDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_attr_read_doubleDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_attr_read_doubleDefinition, "val", "clib.array.libm2k.Double", "input", <SHAPE>, "Description", "val A pointer to a double variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.Double, or double
%defineOutput(iio_device_attr_read_doubleDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_attr_read_doubleDefinition);

%% C++ function |iio_device_attr_write| with MATLAB name |clib.libm2k.iio_device_attr_write|
% C++ Signature: ssize_t iio_device_attr_write(iio_device const * dev,char const * attr,char const * src)
%iio_device_attr_writeDefinition = addFunction(libDef, ...
%    "ssize_t iio_device_attr_write(iio_device const * dev,char const * attr,char const * src)", ...
%    "MATLABName", "clib.libm2k.iio_device_attr_write", ...
%    "Description", "clib.libm2k.iio_device_attr_write    Representation of C++ function iio_device_attr_write." + newline + ...
%    "Set the value of the given device-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_attr_writeDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_attr_writeDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_attr_writeDefinition, "src", <MLTYPE>, "input", <SHAPE>, "Description", "src A NULL-terminated string to set the attribute to"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_device_attr_writeDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written");
%validate(iio_device_attr_writeDefinition);

%% C++ function |iio_device_attr_write_bool| with MATLAB name |clib.libm2k.iio_device_attr_write_bool|
% C++ Signature: int iio_device_attr_write_bool(iio_device const * dev,char const * attr,bool val)
%iio_device_attr_write_boolDefinition = addFunction(libDef, ...
%    "int iio_device_attr_write_bool(iio_device const * dev,char const * attr,bool val)", ...
%    "MATLABName", "clib.libm2k.iio_device_attr_write_bool", ...
%    "Description", "clib.libm2k.iio_device_attr_write_bool    Representation of C++ function iio_device_attr_write_bool." + newline + ...
%    "Set the value of the given device-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_attr_write_boolDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_attr_write_boolDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_attr_write_boolDefinition, "val", "logical", "Description", "val A bool value to set the attribute to");
%defineOutput(iio_device_attr_write_boolDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_attr_write_boolDefinition);

%% C++ function |iio_device_attr_write_longlong| with MATLAB name |clib.libm2k.iio_device_attr_write_longlong|
% C++ Signature: int iio_device_attr_write_longlong(iio_device const * dev,char const * attr,long long val)
%iio_device_attr_write_longlongDefinition = addFunction(libDef, ...
%    "int iio_device_attr_write_longlong(iio_device const * dev,char const * attr,long long val)", ...
%    "MATLABName", "clib.libm2k.iio_device_attr_write_longlong", ...
%    "Description", "clib.libm2k.iio_device_attr_write_longlong    Representation of C++ function iio_device_attr_write_longlong." + newline + ...
%    "Set the value of the given device-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_attr_write_longlongDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_attr_write_longlongDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_attr_write_longlongDefinition, "val", "int64", "Description", "val A long long value to set the attribute to");
%defineOutput(iio_device_attr_write_longlongDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_attr_write_longlongDefinition);

%% C++ function |iio_device_attr_write_double| with MATLAB name |clib.libm2k.iio_device_attr_write_double|
% C++ Signature: int iio_device_attr_write_double(iio_device const * dev,char const * attr,double val)
%iio_device_attr_write_doubleDefinition = addFunction(libDef, ...
%    "int iio_device_attr_write_double(iio_device const * dev,char const * attr,double val)", ...
%    "MATLABName", "clib.libm2k.iio_device_attr_write_double", ...
%    "Description", "clib.libm2k.iio_device_attr_write_double    Representation of C++ function iio_device_attr_write_double." + newline + ...
%    "Set the value of the given device-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_attr_write_doubleDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_attr_write_doubleDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_attr_write_doubleDefinition, "val", "double", "Description", "val A double value to set the attribute to");
%defineOutput(iio_device_attr_write_doubleDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_attr_write_doubleDefinition);

%% C++ function |iio_device_buffer_attr_read| with MATLAB name |clib.libm2k.iio_device_buffer_attr_read|
% C++ Signature: ssize_t iio_device_buffer_attr_read(iio_device const * dev,char const * attr,char * dst,size_t len)
%iio_device_buffer_attr_readDefinition = addFunction(libDef, ...
%    "ssize_t iio_device_buffer_attr_read(iio_device const * dev,char const * attr,char * dst,size_t len)", ...
%    "MATLABName", "clib.libm2k.iio_device_buffer_attr_read", ...
%    "Description", "clib.libm2k.iio_device_buffer_attr_read    Representation of C++ function iio_device_buffer_attr_read." + newline + ...
%    "Read the content of the given buffer-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_buffer_attr_readDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_buffer_attr_readDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_buffer_attr_readDefinition, "dst", <MLTYPE>, "input", <SHAPE>, "Description", "dst A pointer to the memory area where the NULL-terminated string" + newline + ...
%    "corresponding to the value read will be stored"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_buffer_attr_readDefinition, "len", "uint64", "Description", "len The available length of the memory area, in bytes");
%defineOutput(iio_device_buffer_attr_readDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written to the buffer");
%validate(iio_device_buffer_attr_readDefinition);

%% C++ function |iio_device_buffer_attr_read_bool| with MATLAB name |clib.libm2k.iio_device_buffer_attr_read_bool|
% C++ Signature: int iio_device_buffer_attr_read_bool(iio_device const * dev,char const * attr,bool * val)
%iio_device_buffer_attr_read_boolDefinition = addFunction(libDef, ...
%    "int iio_device_buffer_attr_read_bool(iio_device const * dev,char const * attr,bool * val)", ...
%    "MATLABName", "clib.libm2k.iio_device_buffer_attr_read_bool", ...
%    "Description", "clib.libm2k.iio_device_buffer_attr_read_bool    Representation of C++ function iio_device_buffer_attr_read_bool." + newline + ...
%    "Read the content of the given buffer-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_buffer_attr_read_boolDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_buffer_attr_read_boolDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_buffer_attr_read_boolDefinition, "val", "clib.array.libm2k.Bool", "input", <SHAPE>, "Description", "val A pointer to a bool variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.Bool, or logical
%defineOutput(iio_device_buffer_attr_read_boolDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_buffer_attr_read_boolDefinition);

%% C++ function |iio_device_buffer_attr_read_longlong| with MATLAB name |clib.libm2k.iio_device_buffer_attr_read_longlong|
% C++ Signature: int iio_device_buffer_attr_read_longlong(iio_device const * dev,char const * attr,long long * val)
%iio_device_buffer_attr_read_longlongDefinition = addFunction(libDef, ...
%    "int iio_device_buffer_attr_read_longlong(iio_device const * dev,char const * attr,long long * val)", ...
%    "MATLABName", "clib.libm2k.iio_device_buffer_attr_read_longlong", ...
%    "Description", "clib.libm2k.iio_device_buffer_attr_read_longlong    Representation of C++ function iio_device_buffer_attr_read_longlong." + newline + ...
%    "Read the content of the given buffer-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_buffer_attr_read_longlongDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_buffer_attr_read_longlongDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_buffer_attr_read_longlongDefinition, "val", "clib.array.libm2k.LongLong", "input", <SHAPE>, "Description", "val A pointer to a long long variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.LongLong, or int64
%defineOutput(iio_device_buffer_attr_read_longlongDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_buffer_attr_read_longlongDefinition);

%% C++ function |iio_device_buffer_attr_read_double| with MATLAB name |clib.libm2k.iio_device_buffer_attr_read_double|
% C++ Signature: int iio_device_buffer_attr_read_double(iio_device const * dev,char const * attr,double * val)
%iio_device_buffer_attr_read_doubleDefinition = addFunction(libDef, ...
%    "int iio_device_buffer_attr_read_double(iio_device const * dev,char const * attr,double * val)", ...
%    "MATLABName", "clib.libm2k.iio_device_buffer_attr_read_double", ...
%    "Description", "clib.libm2k.iio_device_buffer_attr_read_double    Representation of C++ function iio_device_buffer_attr_read_double." + newline + ...
%    "Read the content of the given buffer-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_buffer_attr_read_doubleDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_buffer_attr_read_doubleDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_buffer_attr_read_doubleDefinition, "val", "clib.array.libm2k.Double", "input", <SHAPE>, "Description", "val A pointer to a double variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.Double, or double
%defineOutput(iio_device_buffer_attr_read_doubleDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_buffer_attr_read_doubleDefinition);

%% C++ function |iio_device_buffer_attr_write| with MATLAB name |clib.libm2k.iio_device_buffer_attr_write|
% C++ Signature: ssize_t iio_device_buffer_attr_write(iio_device const * dev,char const * attr,char const * src)
%iio_device_buffer_attr_writeDefinition = addFunction(libDef, ...
%    "ssize_t iio_device_buffer_attr_write(iio_device const * dev,char const * attr,char const * src)", ...
%    "MATLABName", "clib.libm2k.iio_device_buffer_attr_write", ...
%    "Description", "clib.libm2k.iio_device_buffer_attr_write    Representation of C++ function iio_device_buffer_attr_write." + newline + ...
%    "Set the value of the given buffer-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_buffer_attr_writeDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_buffer_attr_writeDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_buffer_attr_writeDefinition, "src", <MLTYPE>, "input", <SHAPE>, "Description", "src A NULL-terminated string to set the attribute to"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_device_buffer_attr_writeDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written");
%validate(iio_device_buffer_attr_writeDefinition);

%% C++ function |iio_device_buffer_attr_write_bool| with MATLAB name |clib.libm2k.iio_device_buffer_attr_write_bool|
% C++ Signature: int iio_device_buffer_attr_write_bool(iio_device const * dev,char const * attr,bool val)
%iio_device_buffer_attr_write_boolDefinition = addFunction(libDef, ...
%    "int iio_device_buffer_attr_write_bool(iio_device const * dev,char const * attr,bool val)", ...
%    "MATLABName", "clib.libm2k.iio_device_buffer_attr_write_bool", ...
%    "Description", "clib.libm2k.iio_device_buffer_attr_write_bool    Representation of C++ function iio_device_buffer_attr_write_bool." + newline + ...
%    "Set the value of the given buffer-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_buffer_attr_write_boolDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_buffer_attr_write_boolDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_buffer_attr_write_boolDefinition, "val", "logical", "Description", "val A bool value to set the attribute to");
%defineOutput(iio_device_buffer_attr_write_boolDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_buffer_attr_write_boolDefinition);

%% C++ function |iio_device_buffer_attr_write_longlong| with MATLAB name |clib.libm2k.iio_device_buffer_attr_write_longlong|
% C++ Signature: int iio_device_buffer_attr_write_longlong(iio_device const * dev,char const * attr,long long val)
%iio_device_buffer_attr_write_longlongDefinition = addFunction(libDef, ...
%    "int iio_device_buffer_attr_write_longlong(iio_device const * dev,char const * attr,long long val)", ...
%    "MATLABName", "clib.libm2k.iio_device_buffer_attr_write_longlong", ...
%    "Description", "clib.libm2k.iio_device_buffer_attr_write_longlong    Representation of C++ function iio_device_buffer_attr_write_longlong." + newline + ...
%    "Set the value of the given buffer-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_buffer_attr_write_longlongDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_buffer_attr_write_longlongDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_buffer_attr_write_longlongDefinition, "val", "int64", "Description", "val A long long value to set the attribute to");
%defineOutput(iio_device_buffer_attr_write_longlongDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_buffer_attr_write_longlongDefinition);

%% C++ function |iio_device_buffer_attr_write_double| with MATLAB name |clib.libm2k.iio_device_buffer_attr_write_double|
% C++ Signature: int iio_device_buffer_attr_write_double(iio_device const * dev,char const * attr,double val)
%iio_device_buffer_attr_write_doubleDefinition = addFunction(libDef, ...
%    "int iio_device_buffer_attr_write_double(iio_device const * dev,char const * attr,double val)", ...
%    "MATLABName", "clib.libm2k.iio_device_buffer_attr_write_double", ...
%    "Description", "clib.libm2k.iio_device_buffer_attr_write_double    Representation of C++ function iio_device_buffer_attr_write_double." + newline + ...
%    "Set the value of the given buffer-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_buffer_attr_write_doubleDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_buffer_attr_write_doubleDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_buffer_attr_write_doubleDefinition, "val", "double", "Description", "val A double value to set the attribute to");
%defineOutput(iio_device_buffer_attr_write_doubleDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_buffer_attr_write_doubleDefinition);

%% C++ function |iio_device_get_trigger| with MATLAB name |clib.libm2k.iio_device_get_trigger|
% C++ Signature: int iio_device_get_trigger(iio_device const * dev,iio_device const * * trigger)
%iio_device_get_triggerDefinition = addFunction(libDef, ...
%    "int iio_device_get_trigger(iio_device const * dev,iio_device const * * trigger)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_trigger", ...
%    "Description", "clib.libm2k.iio_device_get_trigger    Representation of C++ function iio_device_get_trigger." + newline + ...
%    "Retrieve the trigger of a given device", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_triggerDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_get_triggerDefinition, "trigger", "clib.libm2k.iio_device", "output", 1, "Description", "trigger a pointer to a pointer of an iio_device structure. The pointed" + newline + ...
%    "pointer will be set to the address of the iio_device structure corresponding" + newline + ...
%    "to the associated trigger device.");
%defineOutput(iio_device_get_triggerDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_get_triggerDefinition);

%% C++ function |iio_device_set_trigger| with MATLAB name |clib.libm2k.iio_device_set_trigger|
% C++ Signature: int iio_device_set_trigger(iio_device const * dev,iio_device const * trigger)
%iio_device_set_triggerDefinition = addFunction(libDef, ...
%    "int iio_device_set_trigger(iio_device const * dev,iio_device const * trigger)", ...
%    "MATLABName", "clib.libm2k.iio_device_set_trigger", ...
%    "Description", "clib.libm2k.iio_device_set_trigger    Representation of C++ function iio_device_set_trigger." + newline + ...
%    "Associate a trigger to a given device", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_set_triggerDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_set_triggerDefinition, "trigger", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "trigger a pointer to the iio_device structure corresponding to the" + newline + ...
%    "trigger that should be associated.");
%defineOutput(iio_device_set_triggerDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_set_triggerDefinition);

%% C++ function |iio_device_is_trigger| with MATLAB name |clib.libm2k.iio_device_is_trigger|
% C++ Signature: bool iio_device_is_trigger(iio_device const * dev)
%iio_device_is_triggerDefinition = addFunction(libDef, ...
%    "bool iio_device_is_trigger(iio_device const * dev)", ...
%    "MATLABName", "clib.libm2k.iio_device_is_trigger", ...
%    "Description", "clib.libm2k.iio_device_is_trigger    Representation of C++ function iio_device_is_trigger." + newline + ...
%    "Return True if the given device is a trigger", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_is_triggerDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineOutput(iio_device_is_triggerDefinition, "RetVal", "logical", "Description", "True if the device is a trigger, False otherwise");
%validate(iio_device_is_triggerDefinition);

%% C++ function |iio_device_set_kernel_buffers_count| with MATLAB name |clib.libm2k.iio_device_set_kernel_buffers_count|
% C++ Signature: int iio_device_set_kernel_buffers_count(iio_device const * dev,unsigned int nb_buffers)
%iio_device_set_kernel_buffers_countDefinition = addFunction(libDef, ...
%    "int iio_device_set_kernel_buffers_count(iio_device const * dev,unsigned int nb_buffers)", ...
%    "MATLABName", "clib.libm2k.iio_device_set_kernel_buffers_count", ...
%    "Description", "clib.libm2k.iio_device_set_kernel_buffers_count    Representation of C++ function iio_device_set_kernel_buffers_count." + newline + ...
%    "Configure the number of kernel buffers for a device", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "This function allows to change the number of buffers on kernel side."); % Modify help description values as needed.
%defineArgument(iio_device_set_kernel_buffers_countDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_set_kernel_buffers_countDefinition, "nb_buffers", "uint32", "Description", "nb_buffers The number of buffers");
%defineOutput(iio_device_set_kernel_buffers_countDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_set_kernel_buffers_countDefinition);

%% C++ function |iio_channel_get_device| with MATLAB name |clib.libm2k.iio_channel_get_device|
% C++ Signature: iio_device const * iio_channel_get_device(iio_channel const * chn)
%iio_channel_get_deviceDefinition = addFunction(libDef, ...
%    "iio_device const * iio_channel_get_device(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_get_device", ...
%    "Description", "clib.libm2k.iio_channel_get_device    Representation of C++ function iio_channel_get_device." + newline + ...
%    "Retrieve a pointer to the iio_device structure", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_get_deviceDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_get_deviceDefinition, "RetVal", "clib.libm2k.iio_device", <SHAPE>, "Description", "A pointer to an iio_device structure");
%validate(iio_channel_get_deviceDefinition);

%% C++ function |iio_channel_get_id| with MATLAB name |clib.libm2k.iio_channel_get_id|
% C++ Signature: char const * iio_channel_get_id(iio_channel const * chn)
%iio_channel_get_idDefinition = addFunction(libDef, ...
%    "char const * iio_channel_get_id(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_get_id", ...
%    "Description", "clib.libm2k.iio_channel_get_id    Representation of C++ function iio_channel_get_id." + newline + ...
%    "Retrieve the channel ID (e.g. <b><i>voltage0</i></b>)", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_get_idDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_get_idDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "A pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_channel_get_idDefinition);

%% C++ function |iio_channel_get_name| with MATLAB name |clib.libm2k.iio_channel_get_name|
% C++ Signature: char const * iio_channel_get_name(iio_channel const * chn)
%iio_channel_get_nameDefinition = addFunction(libDef, ...
%    "char const * iio_channel_get_name(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_get_name", ...
%    "Description", "clib.libm2k.iio_channel_get_name    Representation of C++ function iio_channel_get_name." + newline + ...
%    "Retrieve the channel name (e.g. <b><i>vccint</i></b>)", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_get_nameDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_get_nameDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "A pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_channel_get_nameDefinition);

%% C++ function |iio_channel_is_output| with MATLAB name |clib.libm2k.iio_channel_is_output|
% C++ Signature: bool iio_channel_is_output(iio_channel const * chn)
%iio_channel_is_outputDefinition = addFunction(libDef, ...
%    "bool iio_channel_is_output(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_is_output", ...
%    "Description", "clib.libm2k.iio_channel_is_output    Representation of C++ function iio_channel_is_output." + newline + ...
%    "Return True if the given channel is an output channel", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_is_outputDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_is_outputDefinition, "RetVal", "logical", "Description", "True if the channel is an output channel, False otherwise");
%validate(iio_channel_is_outputDefinition);

%% C++ function |iio_channel_is_scan_element| with MATLAB name |clib.libm2k.iio_channel_is_scan_element|
% C++ Signature: bool iio_channel_is_scan_element(iio_channel const * chn)
%iio_channel_is_scan_elementDefinition = addFunction(libDef, ...
%    "bool iio_channel_is_scan_element(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_is_scan_element", ...
%    "Description", "clib.libm2k.iio_channel_is_scan_element    Representation of C++ function iio_channel_is_scan_element." + newline + ...
%    "Return True if the given channel is a scan element", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_is_scan_elementDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_is_scan_elementDefinition, "RetVal", "logical", "Description", "True if the channel is a scan element, False otherwise");
%validate(iio_channel_is_scan_elementDefinition);

%% C++ function |iio_channel_get_attrs_count| with MATLAB name |clib.libm2k.iio_channel_get_attrs_count|
% C++ Signature: unsigned int iio_channel_get_attrs_count(iio_channel const * chn)
%iio_channel_get_attrs_countDefinition = addFunction(libDef, ...
%    "unsigned int iio_channel_get_attrs_count(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_get_attrs_count", ...
%    "Description", "clib.libm2k.iio_channel_get_attrs_count    Representation of C++ function iio_channel_get_attrs_count." + newline + ...
%    "Enumerate the channel-specific attributes of the given channel", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_get_attrs_countDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_get_attrs_countDefinition, "RetVal", "uint32", "Description", "The number of channel-specific attributes found");
%validate(iio_channel_get_attrs_countDefinition);

%% C++ function |iio_channel_get_attr| with MATLAB name |clib.libm2k.iio_channel_get_attr|
% C++ Signature: char const * iio_channel_get_attr(iio_channel const * chn,unsigned int index)
%iio_channel_get_attrDefinition = addFunction(libDef, ...
%    "char const * iio_channel_get_attr(iio_channel const * chn,unsigned int index)", ...
%    "MATLABName", "clib.libm2k.iio_channel_get_attr", ...
%    "Description", "clib.libm2k.iio_channel_get_attr    Representation of C++ function iio_channel_get_attr." + newline + ...
%    "Get the channel-specific attribute present at the given index", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_get_attrDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_get_attrDefinition, "index", "uint32", "Description", "index The index corresponding to the attribute");
%defineOutput(iio_channel_get_attrDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_channel_get_attrDefinition);

%% C++ function |iio_channel_find_attr| with MATLAB name |clib.libm2k.iio_channel_find_attr|
% C++ Signature: char const * iio_channel_find_attr(iio_channel const * chn,char const * name)
%iio_channel_find_attrDefinition = addFunction(libDef, ...
%    "char const * iio_channel_find_attr(iio_channel const * chn,char const * name)", ...
%    "MATLABName", "clib.libm2k.iio_channel_find_attr", ...
%    "Description", "clib.libm2k.iio_channel_find_attr    Representation of C++ function iio_channel_find_attr." + newline + ...
%    "Try to find a channel-specific attribute by its name", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_find_attrDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_find_attrDefinition, "name", <MLTYPE>, "input", <SHAPE>, "Description", "name A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_channel_find_attrDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_channel_find_attrDefinition);

%% C++ function |iio_channel_attr_get_filename| with MATLAB name |clib.libm2k.iio_channel_attr_get_filename|
% C++ Signature: char const * iio_channel_attr_get_filename(iio_channel const * chn,char const * attr)
%iio_channel_attr_get_filenameDefinition = addFunction(libDef, ...
%    "char const * iio_channel_attr_get_filename(iio_channel const * chn,char const * attr)", ...
%    "MATLABName", "clib.libm2k.iio_channel_attr_get_filename", ...
%    "Description", "clib.libm2k.iio_channel_attr_get_filename    Representation of C++ function iio_channel_attr_get_filename." + newline + ...
%    "Retrieve the filename of an attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_attr_get_filenameDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_attr_get_filenameDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr a NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_channel_attr_get_filenameDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_channel_attr_get_filenameDefinition);

%% C++ function |iio_channel_attr_read| with MATLAB name |clib.libm2k.iio_channel_attr_read|
% C++ Signature: ssize_t iio_channel_attr_read(iio_channel const * chn,char const * attr,char * dst,size_t len)
%iio_channel_attr_readDefinition = addFunction(libDef, ...
%    "ssize_t iio_channel_attr_read(iio_channel const * chn,char const * attr,char * dst,size_t len)", ...
%    "MATLABName", "clib.libm2k.iio_channel_attr_read", ...
%    "Description", "clib.libm2k.iio_channel_attr_read    Representation of C++ function iio_channel_attr_read." + newline + ...
%    "Read the content of the given channel-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_attr_readDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_attr_readDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_channel_attr_readDefinition, "dst", <MLTYPE>, "input", <SHAPE>, "Description", "dst A pointer to the memory area where the NULL-terminated string" + newline + ...
%    "corresponding to the value read will be stored"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_channel_attr_readDefinition, "len", "uint64", "Description", "len The available length of the memory area, in bytes");
%defineOutput(iio_channel_attr_readDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written to the buffer");
%validate(iio_channel_attr_readDefinition);

%% C++ function |iio_channel_attr_read_bool| with MATLAB name |clib.libm2k.iio_channel_attr_read_bool|
% C++ Signature: int iio_channel_attr_read_bool(iio_channel const * chn,char const * attr,bool * val)
%iio_channel_attr_read_boolDefinition = addFunction(libDef, ...
%    "int iio_channel_attr_read_bool(iio_channel const * chn,char const * attr,bool * val)", ...
%    "MATLABName", "clib.libm2k.iio_channel_attr_read_bool", ...
%    "Description", "clib.libm2k.iio_channel_attr_read_bool    Representation of C++ function iio_channel_attr_read_bool." + newline + ...
%    "Read the content of the given channel-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_attr_read_boolDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_attr_read_boolDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_channel_attr_read_boolDefinition, "val", "clib.array.libm2k.Bool", "input", <SHAPE>, "Description", "val A pointer to a bool variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.Bool, or logical
%defineOutput(iio_channel_attr_read_boolDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_channel_attr_read_boolDefinition);

%% C++ function |iio_channel_attr_read_longlong| with MATLAB name |clib.libm2k.iio_channel_attr_read_longlong|
% C++ Signature: int iio_channel_attr_read_longlong(iio_channel const * chn,char const * attr,long long * val)
%iio_channel_attr_read_longlongDefinition = addFunction(libDef, ...
%    "int iio_channel_attr_read_longlong(iio_channel const * chn,char const * attr,long long * val)", ...
%    "MATLABName", "clib.libm2k.iio_channel_attr_read_longlong", ...
%    "Description", "clib.libm2k.iio_channel_attr_read_longlong    Representation of C++ function iio_channel_attr_read_longlong." + newline + ...
%    "Read the content of the given channel-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_attr_read_longlongDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_attr_read_longlongDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_channel_attr_read_longlongDefinition, "val", "clib.array.libm2k.LongLong", "input", <SHAPE>, "Description", "val A pointer to a long long variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.LongLong, or int64
%defineOutput(iio_channel_attr_read_longlongDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_channel_attr_read_longlongDefinition);

%% C++ function |iio_channel_attr_read_double| with MATLAB name |clib.libm2k.iio_channel_attr_read_double|
% C++ Signature: int iio_channel_attr_read_double(iio_channel const * chn,char const * attr,double * val)
%iio_channel_attr_read_doubleDefinition = addFunction(libDef, ...
%    "int iio_channel_attr_read_double(iio_channel const * chn,char const * attr,double * val)", ...
%    "MATLABName", "clib.libm2k.iio_channel_attr_read_double", ...
%    "Description", "clib.libm2k.iio_channel_attr_read_double    Representation of C++ function iio_channel_attr_read_double." + newline + ...
%    "Read the content of the given channel-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_attr_read_doubleDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_attr_read_doubleDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_channel_attr_read_doubleDefinition, "val", "clib.array.libm2k.Double", "input", <SHAPE>, "Description", "val A pointer to a double variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.Double, or double
%defineOutput(iio_channel_attr_read_doubleDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_channel_attr_read_doubleDefinition);

%% C++ function |iio_channel_attr_write| with MATLAB name |clib.libm2k.iio_channel_attr_write|
% C++ Signature: ssize_t iio_channel_attr_write(iio_channel const * chn,char const * attr,char const * src)
%iio_channel_attr_writeDefinition = addFunction(libDef, ...
%    "ssize_t iio_channel_attr_write(iio_channel const * chn,char const * attr,char const * src)", ...
%    "MATLABName", "clib.libm2k.iio_channel_attr_write", ...
%    "Description", "clib.libm2k.iio_channel_attr_write    Representation of C++ function iio_channel_attr_write." + newline + ...
%    "Set the value of the given channel-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_attr_writeDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_attr_writeDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_channel_attr_writeDefinition, "src", <MLTYPE>, "input", <SHAPE>, "Description", "src A NULL-terminated string to set the attribute to"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_channel_attr_writeDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written");
%validate(iio_channel_attr_writeDefinition);

%% C++ function |iio_channel_attr_write_bool| with MATLAB name |clib.libm2k.iio_channel_attr_write_bool|
% C++ Signature: int iio_channel_attr_write_bool(iio_channel const * chn,char const * attr,bool val)
%iio_channel_attr_write_boolDefinition = addFunction(libDef, ...
%    "int iio_channel_attr_write_bool(iio_channel const * chn,char const * attr,bool val)", ...
%    "MATLABName", "clib.libm2k.iio_channel_attr_write_bool", ...
%    "Description", "clib.libm2k.iio_channel_attr_write_bool    Representation of C++ function iio_channel_attr_write_bool." + newline + ...
%    "Set the value of the given channel-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_attr_write_boolDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_attr_write_boolDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_channel_attr_write_boolDefinition, "val", "logical", "Description", "val A bool value to set the attribute to");
%defineOutput(iio_channel_attr_write_boolDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_channel_attr_write_boolDefinition);

%% C++ function |iio_channel_attr_write_longlong| with MATLAB name |clib.libm2k.iio_channel_attr_write_longlong|
% C++ Signature: int iio_channel_attr_write_longlong(iio_channel const * chn,char const * attr,long long val)
%iio_channel_attr_write_longlongDefinition = addFunction(libDef, ...
%    "int iio_channel_attr_write_longlong(iio_channel const * chn,char const * attr,long long val)", ...
%    "MATLABName", "clib.libm2k.iio_channel_attr_write_longlong", ...
%    "Description", "clib.libm2k.iio_channel_attr_write_longlong    Representation of C++ function iio_channel_attr_write_longlong." + newline + ...
%    "Set the value of the given channel-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_attr_write_longlongDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_attr_write_longlongDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_channel_attr_write_longlongDefinition, "val", "int64", "Description", "val A long long value to set the attribute to");
%defineOutput(iio_channel_attr_write_longlongDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_channel_attr_write_longlongDefinition);

%% C++ function |iio_channel_attr_write_double| with MATLAB name |clib.libm2k.iio_channel_attr_write_double|
% C++ Signature: int iio_channel_attr_write_double(iio_channel const * chn,char const * attr,double val)
%iio_channel_attr_write_doubleDefinition = addFunction(libDef, ...
%    "int iio_channel_attr_write_double(iio_channel const * chn,char const * attr,double val)", ...
%    "MATLABName", "clib.libm2k.iio_channel_attr_write_double", ...
%    "Description", "clib.libm2k.iio_channel_attr_write_double    Representation of C++ function iio_channel_attr_write_double." + newline + ...
%    "Set the value of the given channel-specific attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_attr_write_doubleDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineArgument(iio_channel_attr_write_doubleDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_channel_attr_write_doubleDefinition, "val", "double", "Description", "val A double value to set the attribute to");
%defineOutput(iio_channel_attr_write_doubleDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_channel_attr_write_doubleDefinition);

%% C++ function |iio_channel_enable| with MATLAB name |clib.libm2k.iio_channel_enable|
% C++ Signature: void iio_channel_enable(iio_channel * chn)
%iio_channel_enableDefinition = addFunction(libDef, ...
%    "void iio_channel_enable(iio_channel * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_enable", ...
%    "Description", "clib.libm2k.iio_channel_enable    Representation of C++ function iio_channel_enable." + newline + ...
%    "Enable the given channel", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_enableDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%validate(iio_channel_enableDefinition);

%% C++ function |iio_channel_disable| with MATLAB name |clib.libm2k.iio_channel_disable|
% C++ Signature: void iio_channel_disable(iio_channel * chn)
%iio_channel_disableDefinition = addFunction(libDef, ...
%    "void iio_channel_disable(iio_channel * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_disable", ...
%    "Description", "clib.libm2k.iio_channel_disable    Representation of C++ function iio_channel_disable." + newline + ...
%    "Disable the given channel", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_disableDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%validate(iio_channel_disableDefinition);

%% C++ function |iio_channel_is_enabled| with MATLAB name |clib.libm2k.iio_channel_is_enabled|
% C++ Signature: bool iio_channel_is_enabled(iio_channel const * chn)
%iio_channel_is_enabledDefinition = addFunction(libDef, ...
%    "bool iio_channel_is_enabled(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_is_enabled", ...
%    "Description", "clib.libm2k.iio_channel_is_enabled    Representation of C++ function iio_channel_is_enabled." + newline + ...
%    "Returns True if the channel is enabled", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_is_enabledDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_is_enabledDefinition, "RetVal", "logical", "Description", "True if the channel is enabled, False otherwise");
%validate(iio_channel_is_enabledDefinition);

%% C++ function |iio_channel_get_type| with MATLAB name |clib.libm2k.iio_channel_get_type|
% C++ Signature: iio_chan_type iio_channel_get_type(iio_channel const * chn)
%iio_channel_get_typeDefinition = addFunction(libDef, ...
%    "iio_chan_type iio_channel_get_type(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_get_type", ...
%    "Description", "clib.libm2k.iio_channel_get_type    Representation of C++ function iio_channel_get_type." + newline + ...
%    "Get the type of the given channel", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_get_typeDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_get_typeDefinition, "RetVal", "clib.libm2k.iio_chan_type", "Description", "The type of the channel");
%validate(iio_channel_get_typeDefinition);

%% C++ function |iio_channel_get_modifier| with MATLAB name |clib.libm2k.iio_channel_get_modifier|
% C++ Signature: iio_modifier iio_channel_get_modifier(iio_channel const * chn)
%iio_channel_get_modifierDefinition = addFunction(libDef, ...
%    "iio_modifier iio_channel_get_modifier(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_get_modifier", ...
%    "Description", "clib.libm2k.iio_channel_get_modifier    Representation of C++ function iio_channel_get_modifier." + newline + ...
%    "Get the modifier type of the given channel", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_get_modifierDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_get_modifierDefinition, "RetVal", "clib.libm2k.iio_modifier", "Description", "The modifier type of the channel");
%validate(iio_channel_get_modifierDefinition);

%% C++ function |iio_buffer_get_device| with MATLAB name |clib.libm2k.iio_buffer_get_device|
% C++ Signature: iio_device const * iio_buffer_get_device(iio_buffer const * buf)
%iio_buffer_get_deviceDefinition = addFunction(libDef, ...
%    "iio_device const * iio_buffer_get_device(iio_buffer const * buf)", ...
%    "MATLABName", "clib.libm2k.iio_buffer_get_device", ...
%    "Description", "clib.libm2k.iio_buffer_get_device    Representation of C++ function iio_buffer_get_device." + newline + ...
%    "Retrieve a pointer to the iio_device structure", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_buffer_get_deviceDefinition, "buf", "clib.libm2k.iio_buffer", "input", <SHAPE>, "Description", "buf A pointer to an iio_buffer structure");
%defineOutput(iio_buffer_get_deviceDefinition, "RetVal", "clib.libm2k.iio_device", <SHAPE>, "Description", "A pointer to an iio_device structure");
%validate(iio_buffer_get_deviceDefinition);

%% C++ function |iio_device_create_buffer| with MATLAB name |clib.libm2k.iio_device_create_buffer|
% C++ Signature: iio_buffer * iio_device_create_buffer(iio_device const * dev,size_t samples_count,bool cyclic)
%iio_device_create_bufferDefinition = addFunction(libDef, ...
%    "iio_buffer * iio_device_create_buffer(iio_device const * dev,size_t samples_count,bool cyclic)", ...
%    "MATLABName", "clib.libm2k.iio_device_create_buffer", ...
%    "Description", "clib.libm2k.iio_device_create_buffer    Representation of C++ function iio_device_create_buffer." + newline + ...
%    "Create an input or output buffer associated to the given device", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_create_bufferDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_create_bufferDefinition, "samples_count", "uint64", "Description", "samples_count The number of samples that the buffer should contain");
%defineArgument(iio_device_create_bufferDefinition, "cyclic", "logical", "Description", "cyclic If True, enable cyclic mode");
%defineOutput(iio_device_create_bufferDefinition, "RetVal", "clib.libm2k.iio_buffer", <SHAPE>, "Description", "On success, a pointer to an iio_buffer structure");
%validate(iio_device_create_bufferDefinition);

%% C++ function |iio_buffer_destroy| with MATLAB name |clib.libm2k.iio_buffer_destroy|
% C++ Signature: void iio_buffer_destroy(iio_buffer * buf)
%iio_buffer_destroyDefinition = addFunction(libDef, ...
%    "void iio_buffer_destroy(iio_buffer * buf)", ...
%    "MATLABName", "clib.libm2k.iio_buffer_destroy", ...
%    "Description", "clib.libm2k.iio_buffer_destroy    Representation of C++ function iio_buffer_destroy." + newline + ...
%    "Destroy the given buffer", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_buffer_destroyDefinition, "buf", "clib.libm2k.iio_buffer", "input", <SHAPE>, "Description", "buf A pointer to an iio_buffer structure");
%validate(iio_buffer_destroyDefinition);

%% C++ function |iio_buffer_get_poll_fd| with MATLAB name |clib.libm2k.iio_buffer_get_poll_fd|
% C++ Signature: int iio_buffer_get_poll_fd(iio_buffer * buf)
%iio_buffer_get_poll_fdDefinition = addFunction(libDef, ...
%    "int iio_buffer_get_poll_fd(iio_buffer * buf)", ...
%    "MATLABName", "clib.libm2k.iio_buffer_get_poll_fd", ...
%    "Description", "clib.libm2k.iio_buffer_get_poll_fd    Representation of C++ function iio_buffer_get_poll_fd." + newline + ...
%    "Get a pollable file descriptor", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "Can be used to know when iio_buffer_refill() or iio_buffer_push() can be" + newline + ...
%    "called"); % Modify help description values as needed.
%defineArgument(iio_buffer_get_poll_fdDefinition, "buf", "clib.libm2k.iio_buffer", "input", <SHAPE>, "Description", "buf A pointer to an iio_buffer structure");
%defineOutput(iio_buffer_get_poll_fdDefinition, "RetVal", "int32", "Description", "On success, valid file descriptor");
%validate(iio_buffer_get_poll_fdDefinition);

%% C++ function |iio_buffer_set_blocking_mode| with MATLAB name |clib.libm2k.iio_buffer_set_blocking_mode|
% C++ Signature: int iio_buffer_set_blocking_mode(iio_buffer * buf,bool blocking)
%iio_buffer_set_blocking_modeDefinition = addFunction(libDef, ...
%    "int iio_buffer_set_blocking_mode(iio_buffer * buf,bool blocking)", ...
%    "MATLABName", "clib.libm2k.iio_buffer_set_blocking_mode", ...
%    "Description", "clib.libm2k.iio_buffer_set_blocking_mode    Representation of C++ function iio_buffer_set_blocking_mode." + newline + ...
%    "Make iio_buffer_refill() and iio_buffer_push() blocking or not", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "After this function has been called with blocking == false," + newline + ...
%    "iio_buffer_refill() and iio_buffer_push() will return -EAGAIN if no data is" + newline + ...
%    "ready." + newline + ...
%    "A device is blocking by default."); % Modify help description values as needed.
%defineArgument(iio_buffer_set_blocking_modeDefinition, "buf", "clib.libm2k.iio_buffer", "input", <SHAPE>, "Description", "buf A pointer to an iio_buffer structure");
%defineArgument(iio_buffer_set_blocking_modeDefinition, "blocking", "logical", "Description", "blocking true if the buffer API should be blocking, else false");
%defineOutput(iio_buffer_set_blocking_modeDefinition, "RetVal", "int32", "Description", "On success, 0");
%validate(iio_buffer_set_blocking_modeDefinition);

%% C++ function |iio_buffer_refill| with MATLAB name |clib.libm2k.iio_buffer_refill|
% C++ Signature: ssize_t iio_buffer_refill(iio_buffer * buf)
%iio_buffer_refillDefinition = addFunction(libDef, ...
%    "ssize_t iio_buffer_refill(iio_buffer * buf)", ...
%    "MATLABName", "clib.libm2k.iio_buffer_refill", ...
%    "Description", "clib.libm2k.iio_buffer_refill    Representation of C++ function iio_buffer_refill." + newline + ...
%    "Fetch more samples from the hardware", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_buffer_refillDefinition, "buf", "clib.libm2k.iio_buffer", "input", <SHAPE>, "Description", "buf A pointer to an iio_buffer structure");
%defineOutput(iio_buffer_refillDefinition, "RetVal", "int64", "Description", "On success, the number of bytes read is returned");
%validate(iio_buffer_refillDefinition);

%% C++ function |iio_buffer_push| with MATLAB name |clib.libm2k.iio_buffer_push|
% C++ Signature: ssize_t iio_buffer_push(iio_buffer * buf)
%iio_buffer_pushDefinition = addFunction(libDef, ...
%    "ssize_t iio_buffer_push(iio_buffer * buf)", ...
%    "MATLABName", "clib.libm2k.iio_buffer_push", ...
%    "Description", "clib.libm2k.iio_buffer_push    Representation of C++ function iio_buffer_push." + newline + ...
%    "Send the samples to the hardware", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_buffer_pushDefinition, "buf", "clib.libm2k.iio_buffer", "input", <SHAPE>, "Description", "buf A pointer to an iio_buffer structure");
%defineOutput(iio_buffer_pushDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written is returned");
%validate(iio_buffer_pushDefinition);

%% C++ function |iio_buffer_push_partial| with MATLAB name |clib.libm2k.iio_buffer_push_partial|
% C++ Signature: ssize_t iio_buffer_push_partial(iio_buffer * buf,size_t samples_count)
%iio_buffer_push_partialDefinition = addFunction(libDef, ...
%    "ssize_t iio_buffer_push_partial(iio_buffer * buf,size_t samples_count)", ...
%    "MATLABName", "clib.libm2k.iio_buffer_push_partial", ...
%    "Description", "clib.libm2k.iio_buffer_push_partial    Representation of C++ function iio_buffer_push_partial." + newline + ...
%    "Send a given number of samples to the hardware", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_buffer_push_partialDefinition, "buf", "clib.libm2k.iio_buffer", "input", <SHAPE>, "Description", "buf A pointer to an iio_buffer structure");
%defineArgument(iio_buffer_push_partialDefinition, "samples_count", "uint64", "Description", "samples_count The number of samples to submit");
%defineOutput(iio_buffer_push_partialDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written is returned");
%validate(iio_buffer_push_partialDefinition);

%% C++ function |iio_buffer_cancel| with MATLAB name |clib.libm2k.iio_buffer_cancel|
% C++ Signature: void iio_buffer_cancel(iio_buffer * buf)
%iio_buffer_cancelDefinition = addFunction(libDef, ...
%    "void iio_buffer_cancel(iio_buffer * buf)", ...
%    "MATLABName", "clib.libm2k.iio_buffer_cancel", ...
%    "Description", "clib.libm2k.iio_buffer_cancel    Representation of C++ function iio_buffer_cancel." + newline + ...
%    "Cancel all buffer operations", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_buffer_cancelDefinition, "buf", "clib.libm2k.iio_buffer", "input", <SHAPE>, "Description", "buf The buffer for which operations should be canceled");
%validate(iio_buffer_cancelDefinition);

%% C++ function |iio_buffer_step| with MATLAB name |clib.libm2k.iio_buffer_step|
% C++ Signature: ptrdiff_t iio_buffer_step(iio_buffer const * buf)
%iio_buffer_stepDefinition = addFunction(libDef, ...
%    "ptrdiff_t iio_buffer_step(iio_buffer const * buf)", ...
%    "MATLABName", "clib.libm2k.iio_buffer_step", ...
%    "Description", "clib.libm2k.iio_buffer_step    Representation of C++ function iio_buffer_step." + newline + ...
%    "Get the step size between two samples of one channel", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_buffer_stepDefinition, "buf", "clib.libm2k.iio_buffer", "input", <SHAPE>, "Description", "buf A pointer to an iio_buffer structure");
%defineOutput(iio_buffer_stepDefinition, "RetVal", "int64", "Description", "the difference between the addresses of two consecutive samples of" + newline + ...
%    "one same channel");
%validate(iio_buffer_stepDefinition);

%% C++ function |iio_device_get_sample_size| with MATLAB name |clib.libm2k.iio_device_get_sample_size|
% C++ Signature: ssize_t iio_device_get_sample_size(iio_device const * dev)
%iio_device_get_sample_sizeDefinition = addFunction(libDef, ...
%    "ssize_t iio_device_get_sample_size(iio_device const * dev)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_sample_size", ...
%    "Description", "clib.libm2k.iio_device_get_sample_size    Representation of C++ function iio_device_get_sample_size." + newline + ...
%    "Get the current sample size", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_sample_sizeDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineOutput(iio_device_get_sample_sizeDefinition, "RetVal", "int64", "Description", "On success, the sample size in bytes");
%validate(iio_device_get_sample_sizeDefinition);

%% C++ function |iio_channel_get_index| with MATLAB name |clib.libm2k.iio_channel_get_index|
% C++ Signature: long iio_channel_get_index(iio_channel const * chn)
%iio_channel_get_indexDefinition = addFunction(libDef, ...
%    "long iio_channel_get_index(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_get_index", ...
%    "Description", "clib.libm2k.iio_channel_get_index    Representation of C++ function iio_channel_get_index." + newline + ...
%    "Get the index of the given channel", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_get_indexDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_get_indexDefinition, "RetVal", "int64", "Description", "On success, the index of the specified channel");
%validate(iio_channel_get_indexDefinition);

%% C++ function |iio_channel_get_data_format| with MATLAB name |clib.libm2k.iio_channel_get_data_format|
% C++ Signature: iio_data_format const * iio_channel_get_data_format(iio_channel const * chn)
%iio_channel_get_data_formatDefinition = addFunction(libDef, ...
%    "iio_data_format const * iio_channel_get_data_format(iio_channel const * chn)", ...
%    "MATLABName", "clib.libm2k.iio_channel_get_data_format", ...
%    "Description", "clib.libm2k.iio_channel_get_data_format    Representation of C++ function iio_channel_get_data_format." + newline + ...
%    "Get a pointer to a channel's data format structure", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_channel_get_data_formatDefinition, "chn", "clib.libm2k.iio_channel", "input", <SHAPE>, "Description", "chn A pointer to an iio_channel structure");
%defineOutput(iio_channel_get_data_formatDefinition, "RetVal", "clib.libm2k.iio_data_format", <SHAPE>, "Description", "A pointer to the channel's iio_data_format structure"); % '<MLTYPE>' can be clib.libm2k.iio_data_format, or clib.array.libm2k.iio_data_format
%validate(iio_channel_get_data_formatDefinition);

%% C++ function |iio_device_get_debug_attrs_count| with MATLAB name |clib.libm2k.iio_device_get_debug_attrs_count|
% C++ Signature: unsigned int iio_device_get_debug_attrs_count(iio_device const * dev)
%iio_device_get_debug_attrs_countDefinition = addFunction(libDef, ...
%    "unsigned int iio_device_get_debug_attrs_count(iio_device const * dev)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_debug_attrs_count", ...
%    "Description", "clib.libm2k.iio_device_get_debug_attrs_count    Representation of C++ function iio_device_get_debug_attrs_count." + newline + ...
%    "Enumerate the debug attributes of the given device", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_debug_attrs_countDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineOutput(iio_device_get_debug_attrs_countDefinition, "RetVal", "uint32", "Description", "The number of debug attributes found");
%validate(iio_device_get_debug_attrs_countDefinition);

%% C++ function |iio_device_get_debug_attr| with MATLAB name |clib.libm2k.iio_device_get_debug_attr|
% C++ Signature: char const * iio_device_get_debug_attr(iio_device const * dev,unsigned int index)
%iio_device_get_debug_attrDefinition = addFunction(libDef, ...
%    "char const * iio_device_get_debug_attr(iio_device const * dev,unsigned int index)", ...
%    "MATLABName", "clib.libm2k.iio_device_get_debug_attr", ...
%    "Description", "clib.libm2k.iio_device_get_debug_attr    Representation of C++ function iio_device_get_debug_attr." + newline + ...
%    "Get the debug attribute present at the given index", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_get_debug_attrDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_get_debug_attrDefinition, "index", "uint32", "Description", "index The index corresponding to the debug attribute");
%defineOutput(iio_device_get_debug_attrDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_device_get_debug_attrDefinition);

%% C++ function |iio_device_find_debug_attr| with MATLAB name |clib.libm2k.iio_device_find_debug_attr|
% C++ Signature: char const * iio_device_find_debug_attr(iio_device const * dev,char const * name)
%iio_device_find_debug_attrDefinition = addFunction(libDef, ...
%    "char const * iio_device_find_debug_attr(iio_device const * dev,char const * name)", ...
%    "MATLABName", "clib.libm2k.iio_device_find_debug_attr", ...
%    "Description", "clib.libm2k.iio_device_find_debug_attr    Representation of C++ function iio_device_find_debug_attr." + newline + ...
%    "Try to find a debug attribute by its name", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_find_debug_attrDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_find_debug_attrDefinition, "name", <MLTYPE>, "input", <SHAPE>, "Description", "name A NULL-terminated string corresponding to the name of the" + newline + ...
%    "debug attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_device_find_debug_attrDefinition, "RetVal", <MLTYPE>, <SHAPE>, "Description", "On success, a pointer to a static NULL-terminated string"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%validate(iio_device_find_debug_attrDefinition);

%% C++ function |iio_device_debug_attr_read| with MATLAB name |clib.libm2k.iio_device_debug_attr_read|
% C++ Signature: ssize_t iio_device_debug_attr_read(iio_device const * dev,char const * attr,char * dst,size_t len)
%iio_device_debug_attr_readDefinition = addFunction(libDef, ...
%    "ssize_t iio_device_debug_attr_read(iio_device const * dev,char const * attr,char * dst,size_t len)", ...
%    "MATLABName", "clib.libm2k.iio_device_debug_attr_read", ...
%    "Description", "clib.libm2k.iio_device_debug_attr_read    Representation of C++ function iio_device_debug_attr_read." + newline + ...
%    "Read the content of the given debug attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_debug_attr_readDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_debug_attr_readDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "debug attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_debug_attr_readDefinition, "dst", <MLTYPE>, "input", <SHAPE>, "Description", "dst A pointer to the memory area where the NULL-terminated string" + newline + ...
%    "corresponding to the value read will be stored"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_debug_attr_readDefinition, "len", "uint64", "Description", "len The available length of the memory area, in bytes");
%defineOutput(iio_device_debug_attr_readDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written to the buffer");
%validate(iio_device_debug_attr_readDefinition);

%% C++ function |iio_device_debug_attr_write| with MATLAB name |clib.libm2k.iio_device_debug_attr_write|
% C++ Signature: ssize_t iio_device_debug_attr_write(iio_device const * dev,char const * attr,char const * src)
%iio_device_debug_attr_writeDefinition = addFunction(libDef, ...
%    "ssize_t iio_device_debug_attr_write(iio_device const * dev,char const * attr,char const * src)", ...
%    "MATLABName", "clib.libm2k.iio_device_debug_attr_write", ...
%    "Description", "clib.libm2k.iio_device_debug_attr_write    Representation of C++ function iio_device_debug_attr_write." + newline + ...
%    "Set the value of the given debug attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_debug_attr_writeDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_debug_attr_writeDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "debug attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_debug_attr_writeDefinition, "src", <MLTYPE>, "input", <SHAPE>, "Description", "src A NULL-terminated string to set the debug attribute to"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(iio_device_debug_attr_writeDefinition, "RetVal", "int64", "Description", "On success, the number of bytes written");
%validate(iio_device_debug_attr_writeDefinition);

%% C++ function |iio_device_debug_attr_read_bool| with MATLAB name |clib.libm2k.iio_device_debug_attr_read_bool|
% C++ Signature: int iio_device_debug_attr_read_bool(iio_device const * dev,char const * attr,bool * val)
%iio_device_debug_attr_read_boolDefinition = addFunction(libDef, ...
%    "int iio_device_debug_attr_read_bool(iio_device const * dev,char const * attr,bool * val)", ...
%    "MATLABName", "clib.libm2k.iio_device_debug_attr_read_bool", ...
%    "Description", "clib.libm2k.iio_device_debug_attr_read_bool    Representation of C++ function iio_device_debug_attr_read_bool." + newline + ...
%    "Read the content of the given debug attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_debug_attr_read_boolDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_debug_attr_read_boolDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "debug attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_debug_attr_read_boolDefinition, "val", "clib.array.libm2k.Bool", "input", <SHAPE>, "Description", "val A pointer to a bool variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.Bool, or logical
%defineOutput(iio_device_debug_attr_read_boolDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_debug_attr_read_boolDefinition);

%% C++ function |iio_device_debug_attr_read_longlong| with MATLAB name |clib.libm2k.iio_device_debug_attr_read_longlong|
% C++ Signature: int iio_device_debug_attr_read_longlong(iio_device const * dev,char const * attr,long long * val)
%iio_device_debug_attr_read_longlongDefinition = addFunction(libDef, ...
%    "int iio_device_debug_attr_read_longlong(iio_device const * dev,char const * attr,long long * val)", ...
%    "MATLABName", "clib.libm2k.iio_device_debug_attr_read_longlong", ...
%    "Description", "clib.libm2k.iio_device_debug_attr_read_longlong    Representation of C++ function iio_device_debug_attr_read_longlong." + newline + ...
%    "Read the content of the given debug attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_debug_attr_read_longlongDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_debug_attr_read_longlongDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "debug attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_debug_attr_read_longlongDefinition, "val", "clib.array.libm2k.LongLong", "input", <SHAPE>, "Description", "val A pointer to a long long variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.LongLong, or int64
%defineOutput(iio_device_debug_attr_read_longlongDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_debug_attr_read_longlongDefinition);

%% C++ function |iio_device_debug_attr_read_double| with MATLAB name |clib.libm2k.iio_device_debug_attr_read_double|
% C++ Signature: int iio_device_debug_attr_read_double(iio_device const * dev,char const * attr,double * val)
%iio_device_debug_attr_read_doubleDefinition = addFunction(libDef, ...
%    "int iio_device_debug_attr_read_double(iio_device const * dev,char const * attr,double * val)", ...
%    "MATLABName", "clib.libm2k.iio_device_debug_attr_read_double", ...
%    "Description", "clib.libm2k.iio_device_debug_attr_read_double    Representation of C++ function iio_device_debug_attr_read_double." + newline + ...
%    "Read the content of the given debug attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_debug_attr_read_doubleDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_debug_attr_read_doubleDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "debug attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_debug_attr_read_doubleDefinition, "val", "clib.array.libm2k.Double", "input", <SHAPE>, "Description", "val A pointer to a double variable where the value should be stored"); % '<MLTYPE>' can be clib.array.libm2k.Double, or double
%defineOutput(iio_device_debug_attr_read_doubleDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_debug_attr_read_doubleDefinition);

%% C++ function |iio_device_debug_attr_write_bool| with MATLAB name |clib.libm2k.iio_device_debug_attr_write_bool|
% C++ Signature: int iio_device_debug_attr_write_bool(iio_device const * dev,char const * attr,bool val)
%iio_device_debug_attr_write_boolDefinition = addFunction(libDef, ...
%    "int iio_device_debug_attr_write_bool(iio_device const * dev,char const * attr,bool val)", ...
%    "MATLABName", "clib.libm2k.iio_device_debug_attr_write_bool", ...
%    "Description", "clib.libm2k.iio_device_debug_attr_write_bool    Representation of C++ function iio_device_debug_attr_write_bool." + newline + ...
%    "Set the value of the given debug attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_debug_attr_write_boolDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_debug_attr_write_boolDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "debug attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_debug_attr_write_boolDefinition, "val", "logical", "Description", "val A bool value to set the debug attribute to");
%defineOutput(iio_device_debug_attr_write_boolDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_debug_attr_write_boolDefinition);

%% C++ function |iio_device_debug_attr_write_longlong| with MATLAB name |clib.libm2k.iio_device_debug_attr_write_longlong|
% C++ Signature: int iio_device_debug_attr_write_longlong(iio_device const * dev,char const * attr,long long val)
%iio_device_debug_attr_write_longlongDefinition = addFunction(libDef, ...
%    "int iio_device_debug_attr_write_longlong(iio_device const * dev,char const * attr,long long val)", ...
%    "MATLABName", "clib.libm2k.iio_device_debug_attr_write_longlong", ...
%    "Description", "clib.libm2k.iio_device_debug_attr_write_longlong    Representation of C++ function iio_device_debug_attr_write_longlong." + newline + ...
%    "Set the value of the given debug attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_debug_attr_write_longlongDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_debug_attr_write_longlongDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "debug attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_debug_attr_write_longlongDefinition, "val", "int64", "Description", "val A long long value to set the debug attribute to");
%defineOutput(iio_device_debug_attr_write_longlongDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_debug_attr_write_longlongDefinition);

%% C++ function |iio_device_debug_attr_write_double| with MATLAB name |clib.libm2k.iio_device_debug_attr_write_double|
% C++ Signature: int iio_device_debug_attr_write_double(iio_device const * dev,char const * attr,double val)
%iio_device_debug_attr_write_doubleDefinition = addFunction(libDef, ...
%    "int iio_device_debug_attr_write_double(iio_device const * dev,char const * attr,double val)", ...
%    "MATLABName", "clib.libm2k.iio_device_debug_attr_write_double", ...
%    "Description", "clib.libm2k.iio_device_debug_attr_write_double    Representation of C++ function iio_device_debug_attr_write_double." + newline + ...
%    "Set the value of the given debug attribute", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_debug_attr_write_doubleDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_debug_attr_write_doubleDefinition, "attr", <MLTYPE>, "input", <SHAPE>, "Description", "attr A NULL-terminated string corresponding to the name of the" + newline + ...
%    "debug attribute"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineArgument(iio_device_debug_attr_write_doubleDefinition, "val", "double", "Description", "val A double value to set the debug attribute to");
%defineOutput(iio_device_debug_attr_write_doubleDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_debug_attr_write_doubleDefinition);

%% C++ function |iio_device_reg_write| with MATLAB name |clib.libm2k.iio_device_reg_write|
% C++ Signature: int iio_device_reg_write(iio_device * dev,uint32_t address,uint32_t value)
%iio_device_reg_writeDefinition = addFunction(libDef, ...
%    "int iio_device_reg_write(iio_device * dev,uint32_t address,uint32_t value)", ...
%    "MATLABName", "clib.libm2k.iio_device_reg_write", ...
%    "Description", "clib.libm2k.iio_device_reg_write    Representation of C++ function iio_device_reg_write." + newline + ...
%    "Set the value of a hardware register", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_reg_writeDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_reg_writeDefinition, "address", "uint32", "Description", "address The address of the register");
%defineArgument(iio_device_reg_writeDefinition, "value", "uint32", "Description", "value The value to set the register to");
%defineOutput(iio_device_reg_writeDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_reg_writeDefinition);

%% C++ function |iio_device_reg_read| with MATLAB name |clib.libm2k.iio_device_reg_read|
% C++ Signature: int iio_device_reg_read(iio_device * dev,uint32_t address,uint32_t * value)
%iio_device_reg_readDefinition = addFunction(libDef, ...
%    "int iio_device_reg_read(iio_device * dev,uint32_t address,uint32_t * value)", ...
%    "MATLABName", "clib.libm2k.iio_device_reg_read", ...
%    "Description", "clib.libm2k.iio_device_reg_read    Representation of C++ function iio_device_reg_read." + newline + ...
%    "Get the value of a hardware register", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(iio_device_reg_readDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>, "Description", "dev A pointer to an iio_device structure");
%defineArgument(iio_device_reg_readDefinition, "address", "uint32", "Description", "address The address of the register");
%defineArgument(iio_device_reg_readDefinition, "value", "clib.array.libm2k.UnsignedInt", "input", <SHAPE>, "Description", "value A pointer to the variable where the value will be written"); % '<MLTYPE>' can be clib.array.libm2k.UnsignedInt, or uint32
%defineOutput(iio_device_reg_readDefinition, "RetVal", "int32", "Description", "On success, 0 is returned");
%validate(iio_device_reg_readDefinition);

%% C++ function |throw_exception| with MATLAB name |clib.libm2k.throw_exception|
% C++ Signature: void throw_exception(libm2k::M2K_EXCEPTION exc_type,std::string exception)
throw_exceptionDefinition = addFunction(libDef, ...
    "void throw_exception(libm2k::M2K_EXCEPTION exc_type,std::string exception)", ...
    "MATLABName", "clib.libm2k.throw_exception", ...
    "Description", "clib.libm2k.throw_exception    Representation of C++ function throw_exception."); % Modify help description values as needed.
defineArgument(throw_exceptionDefinition, "exc_type", "clib.libm2k.libm2k.M2K_EXCEPTION");
defineArgument(throw_exceptionDefinition, "exception", "string");
validate(throw_exceptionDefinition);

%% C++ enumeration |libm2k::M2K_TRIGGER_CONDITION_ANALOG| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_ANALOG|
addEnumeration(libDef, "libm2k::M2K_TRIGGER_CONDITION_ANALOG", "int32",...
    [...
      "RISING_EDGE_ANALOG",...  % 0
      "FALLING_EDGE_ANALOG",...  % 1
      "LOW_LEVEL_ANALOG",...  % 2
      "HIGH_LEVEL_ANALOG",...  % 3
    ],...
    "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_ANALOG", ...
    "Description", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_ANALOG    Representation of C++ enumeration libm2k::M2K_TRIGGER_CONDITION_ANALOG." + newline + ...
    "Condition of triggering", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.

%% C++ enumeration |libm2k::M2K_TRIGGER_CONDITION_DIGITAL| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL|
addEnumeration(libDef, "libm2k::M2K_TRIGGER_CONDITION_DIGITAL", "int32",...
    [...
      "RISING_EDGE_DIGITAL",...  % 0
      "FALLING_EDGE_DIGITAL",...  % 1
      "LOW_LEVEL_DIGITAL",...  % 2
      "HIGH_LEVEL_DIGITAL",...  % 3
      "ANY_EDGE_DIGITAL",...  % 4
      "NO_TRIGGER_DIGITAL",...  % 5
    ],...
    "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", ...
    "Description", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL    Representation of C++ enumeration libm2k::M2K_TRIGGER_CONDITION_DIGITAL." + newline + ...
    "Condition of triggering", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.

%% C++ enumeration |libm2k::M2K_TRIGGER_MODE| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_MODE|
addEnumeration(libDef, "libm2k::M2K_TRIGGER_MODE", "int32",...
    [...
      "ALWAYS",...  % 0
      "ANALOG",...  % 1
      "EXTERNAL",...  % 2
      "DIGITAL_OR_ANALOG",...  % 3
      "DIGITAL_AND_ANALOG",...  % 4
      "DIGITAL_XOR_ANALOG",...  % 5
      "N_DIGITAL_OR_ANALOG",...  % 6
      "N_DIGITAL_AND_ANALOG",...  % 7
      "N_DIGITAL_XOR_ANALOG",...  % 8
    ],...
    "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_MODE", ...
    "Description", "clib.libm2k.libm2k.M2K_TRIGGER_MODE    Representation of C++ enumeration libm2k::M2K_TRIGGER_MODE." + newline + ...
    "Select the mode for the analog trigger", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@enum M2K_TRIGGER_MODE" + newline + ...
    "	@brief Select the mode for the analog trigger", ...
    "EnumerantDescriptions", ...
    [...
      "ALWAYS - Disable analog trigger;",...  % ALWAYS
      "ANALOG - Trigger condition specified only by analog trigger (CH1 and CH2)",...  % ANALOG
      "EXTERNAL - Trigger condition specified only by external trigger (TI)",...  % EXTERNAL
      "",...  % DIGITAL_OR_ANALOG
      "",...  % DIGITAL_AND_ANALOG
      "",...  % DIGITAL_XOR_ANALOG
      "",...  % N_DIGITAL_OR_ANALOG
      "",...  % N_DIGITAL_AND_ANALOG
      "",...  % N_DIGITAL_XOR_ANALOG
    ]); % Modify help description values as needed.

%% C++ enumeration |libm2k::M2K_TRIGGER_SOURCE_ANALOG| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG|
addEnumeration(libDef, "libm2k::M2K_TRIGGER_SOURCE_ANALOG", "int32",...
    [...
      "CHANNEL_1",...  % 0
      "CHANNEL_2",...  % 1
      "CHANNEL_1_OR_CHANNEL_2",...  % 2
      "CHANNEL_1_AND_CHANNEL_2",...  % 3
      "CHANNEL_1_XOR_CHANNEL_2",...  % 4
      "SRC_DIGITAL_IN",...  % 5
      "CHANNEL_1_OR_SRC_LOGIC_ANALYZER",...  % 6
      "CHANNEL_2_OR_SRC_LOGIC_ANALYZER",...  % 7
      "CHANNEL_1_OR_CHANNEL_2_OR_SRC_LOGIC_ANALYZER",...  % 8
    ],...
    "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG", ...
    "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG    Representation of C++ enumeration libm2k::M2K_TRIGGER_SOURCE_ANALOG." + newline + ...
    "Select the source for the analog trigger", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@enum M2K_TRIGGER_SOURCE_ANALOG" + newline + ...
    "	@brief Select the source for the analog trigger", ...
    "EnumerantDescriptions", ...
    [...
      "CHANNEL_1 - trigger events on analog CHANNEL_1 trigger the AnalogIn interface",...  % CHANNEL_1
      "CHANNEL_2 - trigger events on analog CHANNEL_2 trigger the AnalogIn interface",...  % CHANNEL_2
      "",...  % CHANNEL_1_OR_CHANNEL_2
      "",...  % CHANNEL_1_AND_CHANNEL_2
      "",...  % CHANNEL_1_XOR_CHANNEL_2
      "SRC_DIGITAL_IN - trigger events on the DigitalIn interface trigger the AnalogIn interface",...  % SRC_DIGITAL_IN
      "",...  % CHANNEL_1_OR_SRC_LOGIC_ANALYZER
      "",...  % CHANNEL_2_OR_SRC_LOGIC_ANALYZER
      "",...  % CHANNEL_1_OR_CHANNEL_2_OR_SRC_LOGIC_ANALYZER
    ]); % Modify help description values as needed.

%% C++ class |libm2k::SETTINGS| with MATLAB name |clib.libm2k.libm2k.SETTINGS|
SETTINGSDefinition = addClass(libDef, "libm2k::SETTINGS", "MATLABName", "clib.libm2k.libm2k.SETTINGS", ...
    "Description", "clib.libm2k.libm2k.SETTINGS    Representation of C++ class libm2k::SETTINGS." + newline + ...
    "Triggering system", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.

%% C++ class constructor for C++ class |libm2k::SETTINGS|
% C++ Signature: libm2k::SETTINGS::SETTINGS()
SETTINGSConstructor1Definition = addConstructor(SETTINGSDefinition, ...
    "libm2k::SETTINGS::SETTINGS()", ...
    "Description", "clib.libm2k.libm2k.SETTINGS.SETTINGS    Constructor of C++ class libm2k::SETTINGS."); % Modify help description values as needed.
validate(SETTINGSConstructor1Definition);

%% C++ class constructor for C++ class |libm2k::SETTINGS|
% C++ Signature: libm2k::SETTINGS::SETTINGS(libm2k::SETTINGS const & input1)
SETTINGSConstructor2Definition = addConstructor(SETTINGSDefinition, ...
    "libm2k::SETTINGS::SETTINGS(libm2k::SETTINGS const & input1)", ...
    "Description", "clib.libm2k.libm2k.SETTINGS.SETTINGS    Constructor of C++ class libm2k::SETTINGS."); % Modify help description values as needed.
defineArgument(SETTINGSConstructor2Definition, "input1", "clib.libm2k.libm2k.SETTINGS", "input");
validate(SETTINGSConstructor2Definition);

%% C++ class public data member |trigger_source| for C++ class |libm2k::SETTINGS|
% C++ Signature: libm2k::M2K_TRIGGER_SOURCE_ANALOG libm2k::SETTINGS::trigger_source
addProperty(SETTINGSDefinition, "trigger_source", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG", ...
    "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG    Data member of C++ class libm2k::SETTINGS." + newline + ...
    "Triggering source"); % Modify help description values as needed.

%% C++ class public data member |delay| for C++ class |libm2k::SETTINGS|
% C++ Signature: int libm2k::SETTINGS::delay
addProperty(SETTINGSDefinition, "delay", "int32", ...
    "Description", "int32    Data member of C++ class libm2k::SETTINGS." + newline + ...
    "Trigger's delay"); % Modify help description values as needed.

%% C++ enumeration |libm2k::M2K_TRIGGER_OUT_SELECT| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT|
addEnumeration(libDef, "libm2k::M2K_TRIGGER_OUT_SELECT", "int32",...
    [...
      "SELECT_NONE",...  % 0
      "SELECT_TRIGGER_I_SAME_CHAN",...  % 1
      "SELECT_TRIGGER_IN",...  % 2
      "SELECT_ANALOG_IN",...  % 3
      "SELECT_DIGITAL_IN",...  % 4
    ],...
    "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT", ...
    "Description", "clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT    Representation of C++ enumeration libm2k::M2K_TRIGGER_OUT_SELECT." + newline + ...
    "Select which trigger event will be forwarded on TO pin (trigger out)", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@enum M2K_TRIGGER_OUT_SELECT" + newline + ...
    "	 @brief Select which trigger event will be forwarded on TO pin (trigger out)", ...
    "EnumerantDescriptions", ...
    [...
      "SELECT_NONE - no trigger event is forwarded",...  % SELECT_NONE
      "",...  % SELECT_TRIGGER_I_SAME_CHAN
      "SELECT_TRIGGER_IN - forwards trigger events from TI pin(trigger in)",...  % SELECT_TRIGGER_IN
      "SELECT_ANALOG_IN  - forwards trigger events from AnalogIn interface",...  % SELECT_ANALOG_IN
      "SELECT_DIGITAL_IN - forwards trigger events from DigitalIn interface",...  % SELECT_DIGITAL_IN
    ]); % Modify help description values as needed.

%% C++ enumeration |libm2k::M2K_TRIGGER_SOURCE_DIGITAL| with MATLAB name |clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL|
addEnumeration(libDef, "libm2k::M2K_TRIGGER_SOURCE_DIGITAL", "int32",...
    [...
      "SRC_TRIGGER_IN",...  % 0
      "SRC_ANALOG_IN",...  % 1
      "SRC_NONE",...  % 2
    ],...
    "MATLABName", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL", ...
    "Description", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL    Representation of C++ enumeration libm2k::M2K_TRIGGER_SOURCE_DIGITAL." + newline + ...
    "Select the source for the digital trigger", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@enum M2K_TRIGGER_SOURCE_DIGITAL" + newline + ...
    "	 @brief Select the source for the digital trigger", ...
    "EnumerantDescriptions", ...
    [...
      "SRC_TRIGGER_IN - trigger events on the TI(trigger in) pin trigger the DigitalIn interface",...  % SRC_TRIGGER_IN
      "SRC_ANALOG_IN - trigger events on the AnalogIn interface trigger the DigitalIn interface",...  % SRC_ANALOG_IN
      "SRC_NONE - trigger events on the DigitalIn are conditioned by the internal digital trigger structure",...  % SRC_NONE
    ]); % Modify help description values as needed.

%% C++ class |libm2k::M2kHardwareTrigger| with MATLAB name |clib.libm2k.libm2k.M2kHardwareTrigger|
M2kHardwareTriggerDefinition = addClass(libDef, "libm2k::M2kHardwareTrigger", "MATLABName", "clib.libm2k.libm2k.M2kHardwareTrigger", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger    Representation of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Contains the representation of the ADALM2000 trigger system" + newline + ...
    "" + newline + ...
    "@class M2kHardwareTrigger" + newline + ...
    "@brief Controls the hardware trigger for ADALM2000", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@defgroup m2ktrigger HardwareTrigger" + newline + ...
    "@brief Contains the representation of the ADALM2000 trigger system" + newline + ...
    "" + newline + ...
    "@class M2kHardwareTrigger" + newline + ...
    "@brief Controls the hardware trigger for ADALM2000"); % Modify help description values as needed.

%% C++ class method |reset| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::reset()
resetDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::reset()", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.reset    Method of C++ class libm2k::M2kHardwareTrigger.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(resetDefinition);

%% C++ class method |getAnalogLevelRaw| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: int libm2k::M2kHardwareTrigger::getAnalogLevelRaw(unsigned int chnIdx)
getAnalogLevelRawDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "int libm2k::M2kHardwareTrigger::getAnalogLevelRaw(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogLevelRaw    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the raw analog trigger level for one channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getAnalogLevelRawDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineOutput(getAnalogLevelRawDefinition, "RetVal", "int32", "Description", "the raw analog trigger level");
validate(getAnalogLevelRawDefinition);

%% C++ class method |setAnalogLevelRaw| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogLevelRaw(unsigned int chnIdx,int level)
setAnalogLevelRawDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogLevelRaw(unsigned int chnIdx,int level)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogLevelRaw    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the raw analog trigger level for one channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogLevelRawDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineArgument(setAnalogLevelRawDefinition, "level", "int32", "Description", "level the raw analog trigger level");
validate(setAnalogLevelRawDefinition);

%% C++ class method |setAnalogLevel| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogLevel(unsigned int chnIdx,double v_level)
setAnalogLevelDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogLevel(unsigned int chnIdx,double v_level)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogLevel    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the analog trigger level for one channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogLevelDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineArgument(setAnalogLevelDefinition, "v_level", "double", "Description", "v_level the analog trigger level in volts");
validate(setAnalogLevelDefinition);

%% C++ class method |getAnalogLevel| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: double libm2k::M2kHardwareTrigger::getAnalogLevel(unsigned int chnIdx)
getAnalogLevelDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "double libm2k::M2kHardwareTrigger::getAnalogLevel(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogLevel    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the analog trigger level for one channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getAnalogLevelDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineOutput(getAnalogLevelDefinition, "RetVal", "double", "Description", "the analog trigger level in volts");
validate(getAnalogLevelDefinition);

%% C++ class method |getAnalogHysteresis| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: double libm2k::M2kHardwareTrigger::getAnalogHysteresis(unsigned int chnIdx)
getAnalogHysteresisDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "double libm2k::M2kHardwareTrigger::getAnalogHysteresis(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogHysteresis    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the analog hysteresis value for one channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getAnalogHysteresisDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineOutput(getAnalogHysteresisDefinition, "RetVal", "double", "Description", "the value of the hysteresis in Volts");
validate(getAnalogHysteresisDefinition);

%% C++ class method |setAnalogHysteresis| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogHysteresis(unsigned int chnIdx,double hysteresis)
setAnalogHysteresisDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogHysteresis(unsigned int chnIdx,double hysteresis)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogHysteresis    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the analog hysteresis value for one channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogHysteresisDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineArgument(setAnalogHysteresisDefinition, "hysteresis", "double", "Description", "hysteresis in Volts");
validate(setAnalogHysteresisDefinition);

%% C++ class method |getAnalogCondition| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::M2K_TRIGGER_CONDITION_ANALOG libm2k::M2kHardwareTrigger::getAnalogCondition(unsigned int chnIdx)
getAnalogConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "libm2k::M2K_TRIGGER_CONDITION_ANALOG libm2k::M2kHardwareTrigger::getAnalogCondition(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogCondition    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the trigger condition for the analog trigger on a specific channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getAnalogConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineOutput(getAnalogConditionDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_ANALOG", "Description", "the trigger condition");
validate(getAnalogConditionDefinition);

%% C++ class method |setAnalogCondition| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogCondition(unsigned int chnIdx,libm2k::M2K_TRIGGER_CONDITION_ANALOG cond)
setAnalogConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogCondition(unsigned int chnIdx,libm2k::M2K_TRIGGER_CONDITION_ANALOG cond)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogCondition    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the trigger condition for the analog trigger on a specific channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineArgument(setAnalogConditionDefinition, "cond", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_ANALOG", "Description", "cond the specific trigger condition");
validate(setAnalogConditionDefinition);

%% C++ class method |getDigitalCondition| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::M2K_TRIGGER_CONDITION_DIGITAL libm2k::M2kHardwareTrigger::getDigitalCondition(unsigned int chnIdx)
getDigitalConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "libm2k::M2K_TRIGGER_CONDITION_DIGITAL libm2k::M2kHardwareTrigger::getDigitalCondition(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getDigitalCondition    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the trigger condition for the digital trigger on a specific channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getDigitalConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineOutput(getDigitalConditionDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "the trigger condition");
validate(getDigitalConditionDefinition);

%% C++ class method |setDigitalCondition| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setDigitalCondition(unsigned int chnIdx,libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)
setDigitalConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setDigitalCondition(unsigned int chnIdx,libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setDigitalCondition    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the trigger condition for the digital trigger on a specific channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDigitalConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineArgument(setDigitalConditionDefinition, "cond", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "cond the specific trigger condition");
validate(setDigitalConditionDefinition);

%% C++ class method |getAnalogMode| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::M2K_TRIGGER_MODE libm2k::M2kHardwareTrigger::getAnalogMode(unsigned int chnIdx)
getAnalogModeDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "libm2k::M2K_TRIGGER_MODE libm2k::M2kHardwareTrigger::getAnalogMode(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogMode    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the mode for the analog trigger on a specific channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getAnalogModeDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineOutput(getAnalogModeDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_MODE", "Description", "the analog trigger mode");
validate(getAnalogModeDefinition);

%% C++ class method |setAnalogMode| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogMode(unsigned int chnIdx,libm2k::M2K_TRIGGER_MODE mode)
setAnalogModeDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogMode(unsigned int chnIdx,libm2k::M2K_TRIGGER_MODE mode)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogMode    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the mode for the analog trigger on a specific channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogModeDefinition, "chnIdx", "uint32", "Description", "chnIdx the required channel");
defineArgument(setAnalogModeDefinition, "mode", "clib.libm2k.libm2k.M2K_TRIGGER_MODE", "Description", "mode the analog trigger mode");
validate(setAnalogModeDefinition);

%% C++ class method |getDigitalMode| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::digital::DIO_TRIGGER_MODE libm2k::M2kHardwareTrigger::getDigitalMode()
getDigitalModeDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "libm2k::digital::DIO_TRIGGER_MODE libm2k::M2kHardwareTrigger::getDigitalMode()", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getDigitalMode    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the mode for the digital trigger", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getDigitalModeDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE", "Description", "the digital trigger mode (DIO_OR/DIO_AND)");
validate(getDigitalModeDefinition);

%% C++ class method |setDigitalMode| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setDigitalMode(libm2k::digital::DIO_TRIGGER_MODE mode)
setDigitalModeDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setDigitalMode(libm2k::digital::DIO_TRIGGER_MODE mode)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setDigitalMode    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the mode for the digital trigger", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDigitalModeDefinition, "mode", "clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE", "Description", "mode the digital trigger mode (DIO_OR/DIO_AND)");
validate(setDigitalModeDefinition);

%% C++ class method |getAnalogSource| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::M2K_TRIGGER_SOURCE_ANALOG libm2k::M2kHardwareTrigger::getAnalogSource()
getAnalogSourceDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "libm2k::M2K_TRIGGER_SOURCE_ANALOG libm2k::M2kHardwareTrigger::getAnalogSource()", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogSource    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the source of the analog trigger", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getAnalogSourceDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG", "Description", "analog trigger source (channel1, channel2, etc)");
validate(getAnalogSourceDefinition);

%% C++ class method |setAnalogSource| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogSource(libm2k::M2K_TRIGGER_SOURCE_ANALOG src)
setAnalogSourceDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogSource(libm2k::M2K_TRIGGER_SOURCE_ANALOG src)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogSource    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the source of the analog trigger", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogSourceDefinition, "src", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_ANALOG", "Description", "src analog trigger source (channel1, channel2, etc)");
validate(setAnalogSourceDefinition);

%% C++ class method |getAnalogSourceChannel| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: int libm2k::M2kHardwareTrigger::getAnalogSourceChannel()
getAnalogSourceChannelDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "int libm2k::M2kHardwareTrigger::getAnalogSourceChannel()", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogSourceChannel    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the channel source of the analog trigger", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getAnalogSourceChannelDefinition, "RetVal", "int32", "Description", "analog trigger channel source (channel1, channel2)");
validate(getAnalogSourceChannelDefinition);

%% C++ class method |setAnalogSourceChannel| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogSourceChannel(unsigned int chnIdx)
setAnalogSourceChannelDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogSourceChannel(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogSourceChannel    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the channel source of the analog trigger", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogSourceChannelDefinition, "chnIdx", "uint32", "Description", "chnIdx the index of the channel that should be used");
validate(setAnalogSourceChannelDefinition);

%% C++ class method |getAnalogDelay| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: int libm2k::M2kHardwareTrigger::getAnalogDelay() const
getAnalogDelayDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "int libm2k::M2kHardwareTrigger::getAnalogDelay() const", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogDelay    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the analog trigger delay", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getAnalogDelayDefinition, "RetVal", "int32", "Description", "the value of the delay");
validate(getAnalogDelayDefinition);

%% C++ class method |setAnalogDelay| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogDelay(int delay)
setAnalogDelayDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogDelay(int delay)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogDelay    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the analog trigger delay", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogDelayDefinition, "delay", "int32", "Description", "delay the value of the analog delay");
validate(setAnalogDelayDefinition);

%% C++ class method |getDigitalDelay| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: int libm2k::M2kHardwareTrigger::getDigitalDelay() const
getDigitalDelayDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "int libm2k::M2kHardwareTrigger::getDigitalDelay() const", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getDigitalDelay    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the digital trigger delay", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getDigitalDelayDefinition, "RetVal", "int32", "Description", "the value of the digital delay");
validate(getDigitalDelayDefinition);

%% C++ class method |setDigitalDelay| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setDigitalDelay(int delay)
setDigitalDelayDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setDigitalDelay(int delay)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setDigitalDelay    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the digital trigger delay", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDigitalDelayDefinition, "delay", "int32", "Description", "delay the value of the digital delay");
validate(setDigitalDelayDefinition);

%% C++ class method |getCurrentHwSettings| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::SETTINGS * libm2k::M2kHardwareTrigger::getCurrentHwSettings()
%getCurrentHwSettingsDefinition = addMethod(M2kHardwareTriggerDefinition, ...
%    "libm2k::SETTINGS * libm2k::M2kHardwareTrigger::getCurrentHwSettings()", ...
%    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getCurrentHwSettings    Method of C++ class libm2k::M2kHardwareTrigger.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineOutput(getCurrentHwSettingsDefinition, "RetVal", "clib.libm2k.libm2k.SETTINGS", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.SETTINGS, or clib.array.libm2k.libm2k.SETTINGS
%validate(getCurrentHwSettingsDefinition);

%% C++ class method |setHwTriggerSettings| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setHwTriggerSettings(libm2k::SETTINGS * settings)
%setHwTriggerSettingsDefinition = addMethod(M2kHardwareTriggerDefinition, ...
%    "void libm2k::M2kHardwareTrigger::setHwTriggerSettings(libm2k::SETTINGS * settings)", ...
%    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setHwTriggerSettings    Method of C++ class libm2k::M2kHardwareTrigger.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineArgument(setHwTriggerSettingsDefinition, "settings", "clib.libm2k.libm2k.SETTINGS", "input", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.SETTINGS, or clib.array.libm2k.libm2k.SETTINGS
%validate(setHwTriggerSettingsDefinition);

%% C++ class method |setAnalogStreamingFlag| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogStreamingFlag(bool enable)
setAnalogStreamingFlagDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogStreamingFlag(bool enable)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogStreamingFlag    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the streaming flag for the analog part", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogStreamingFlagDefinition, "enable", "logical", "Description", "enable the streaming");
validate(setAnalogStreamingFlagDefinition);

%% C++ class method |getAnalogStreamingFlag| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: bool libm2k::M2kHardwareTrigger::getAnalogStreamingFlag()
getAnalogStreamingFlagDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "bool libm2k::M2kHardwareTrigger::getAnalogStreamingFlag()", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogStreamingFlag    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the streaming flag for the analog part", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getAnalogStreamingFlagDefinition, "RetVal", "logical", "Description", "whether the streaming is enabled (true/false)");
validate(getAnalogStreamingFlagDefinition);

%% C++ class method |setDigitalStreamingFlag| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setDigitalStreamingFlag(bool enable)
setDigitalStreamingFlagDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setDigitalStreamingFlag(bool enable)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setDigitalStreamingFlag    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Set the streaming flag for the digital part", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDigitalStreamingFlagDefinition, "enable", "logical", "Description", "enable the streaming");
validate(setDigitalStreamingFlagDefinition);

%% C++ class method |getDigitalStreamingFlag| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: bool libm2k::M2kHardwareTrigger::getDigitalStreamingFlag()
getDigitalStreamingFlagDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "bool libm2k::M2kHardwareTrigger::getDigitalStreamingFlag()", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getDigitalStreamingFlag    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Get the streaming flag for the digital part", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getDigitalStreamingFlagDefinition, "RetVal", "logical", "Description", "whether the streaming is enabled (true/false)");
validate(getDigitalStreamingFlagDefinition);

%% C++ class method |setCalibParameters| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setCalibParameters(unsigned int chnIdx,double scaling,double vert_offset)
setCalibParametersDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setCalibParameters(unsigned int chnIdx,double scaling,double vert_offset)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setCalibParameters    Method of C++ class libm2k::M2kHardwareTrigger.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineArgument(setCalibParametersDefinition, "chnIdx", "uint32");
defineArgument(setCalibParametersDefinition, "scaling", "double");
defineArgument(setCalibParametersDefinition, "vert_offset", "double");
validate(setCalibParametersDefinition);

%% C++ class method |getAnalogExternalCondition| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::M2K_TRIGGER_CONDITION_DIGITAL libm2k::M2kHardwareTrigger::getAnalogExternalCondition(unsigned int chnIdx)
getAnalogExternalConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "libm2k::M2K_TRIGGER_CONDITION_DIGITAL libm2k::M2kHardwareTrigger::getAnalogExternalCondition(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogExternalCondition    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "getAnalogExternalCondition", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getAnalogExternalConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx : integer - the index of the required channel");
defineOutput(getAnalogExternalConditionDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "M2K_TRIGGER_CONDITION_DIGITAL");
validate(getAnalogExternalConditionDefinition);

%% C++ class method |setAnalogExternalCondition| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogExternalCondition(unsigned int chnIdx,libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)
setAnalogExternalConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogExternalCondition(unsigned int chnIdx,libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogExternalCondition    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "setAnalogExternalCondition", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogExternalConditionDefinition, "chnIdx", "uint32", "Description", "chnIdx : integer - the index of the required channel");
defineArgument(setAnalogExternalConditionDefinition, "cond", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "cond : M2K_TRIGGER_CONDITION_DIGITAL");
validate(setAnalogExternalConditionDefinition);

%% C++ class method |getDigitalExternalCondition| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::M2K_TRIGGER_CONDITION_DIGITAL libm2k::M2kHardwareTrigger::getDigitalExternalCondition() const
getDigitalExternalConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "libm2k::M2K_TRIGGER_CONDITION_DIGITAL libm2k::M2kHardwareTrigger::getDigitalExternalCondition() const", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getDigitalExternalCondition    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "getDigitalExternalCondition", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getDigitalExternalConditionDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "M2K_TRIGGER_CONDITION_DIGITAL");
validate(getDigitalExternalConditionDefinition);

%% C++ class method |setDigitalExternalCondition| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setDigitalExternalCondition(libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)
setDigitalExternalConditionDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setDigitalExternalCondition(libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setDigitalExternalCondition    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "setDigitalExternalCondition", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDigitalExternalConditionDefinition, "cond", "clib.libm2k.libm2k.M2K_TRIGGER_CONDITION_DIGITAL", "Description", "cond : M2K_TRIGGER_CONDITION_DIGITAL");
validate(setDigitalExternalConditionDefinition);

%% C++ class method |setAnalogExternalOutSelect| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setAnalogExternalOutSelect(libm2k::M2K_TRIGGER_OUT_SELECT output_select)
setAnalogExternalOutSelectDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setAnalogExternalOutSelect(libm2k::M2K_TRIGGER_OUT_SELECT output_select)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setAnalogExternalOutSelect    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Select what should be redirected on the TO (trigger out) pin.\n" + newline + ...
    "	 *	The options are (none, trigger in, digital in, analog in).\n", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAnalogExternalOutSelectDefinition, "output_select", "clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT", "Description", "output_select : of type M2K_TRIGGER_OUT_SELECT:\n" + newline + ...
    "	 *	SELECT_TRIGGER_IN - forwards trigger events from TI pin(trigger in);\n" + newline + ...
    "	 *	SELECT_DIGITAL_IN - forwards trigger events from DigitalIn interface;\n" + newline + ...
    "	 *	SELECT_ANALOG_IN  - forwards trigger events from AnalogIn interface;\n" + newline + ...
    "	 *	SELECT_NONE - no trigger event is forwarded;\n");
validate(setAnalogExternalOutSelectDefinition);

%% C++ class method |getAnalogExternalOutSelect| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::M2K_TRIGGER_OUT_SELECT libm2k::M2kHardwareTrigger::getAnalogExternalOutSelect()
getAnalogExternalOutSelectDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "libm2k::M2K_TRIGGER_OUT_SELECT libm2k::M2kHardwareTrigger::getAnalogExternalOutSelect()", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getAnalogExternalOutSelect    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Check which trigger events are forwarded on the TO (trigger out) pin.", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getAnalogExternalOutSelectDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_OUT_SELECT", "Description", "M2K_TRIGGER_OUT_SELECT :\n" + newline + ...
    "	 *	SELECT_NONE;\n" + newline + ...
    "	 *	SELECT_TRIGGER_IN;\n" + newline + ...
    "	 *	SELECT_DIGITAL_IN;\n" + newline + ...
    "	 *	SELECT_ANALOG_IN;\n" + newline + ...
    "	 @note Only available from firmware v0.24.");
validate(getAnalogExternalOutSelectDefinition);

%% C++ class method |hasExternalTriggerIn| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: bool libm2k::M2kHardwareTrigger::hasExternalTriggerIn() const
hasExternalTriggerInDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "bool libm2k::M2kHardwareTrigger::hasExternalTriggerIn() const", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.hasExternalTriggerIn    Method of C++ class libm2k::M2kHardwareTrigger.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineOutput(hasExternalTriggerInDefinition, "RetVal", "logical");
validate(hasExternalTriggerInDefinition);

%% C++ class method |hasExternalTriggerOut| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: bool libm2k::M2kHardwareTrigger::hasExternalTriggerOut() const
hasExternalTriggerOutDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "bool libm2k::M2kHardwareTrigger::hasExternalTriggerOut() const", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.hasExternalTriggerOut    Method of C++ class libm2k::M2kHardwareTrigger.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineOutput(hasExternalTriggerOutDefinition, "RetVal", "logical");
validate(hasExternalTriggerOutDefinition);

%% C++ class method |hasCrossInstrumentTrigger| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: bool libm2k::M2kHardwareTrigger::hasCrossInstrumentTrigger() const
hasCrossInstrumentTriggerDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "bool libm2k::M2kHardwareTrigger::hasCrossInstrumentTrigger() const", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.hasCrossInstrumentTrigger    Method of C++ class libm2k::M2kHardwareTrigger.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineOutput(hasCrossInstrumentTriggerDefinition, "RetVal", "logical");
validate(hasCrossInstrumentTriggerDefinition);

%% C++ class method |setDigitalSource| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: void libm2k::M2kHardwareTrigger::setDigitalSource(libm2k::M2K_TRIGGER_SOURCE_DIGITAL external_src)
setDigitalSourceDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "void libm2k::M2kHardwareTrigger::setDigitalSource(libm2k::M2K_TRIGGER_SOURCE_DIGITAL external_src)", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.setDigitalSource    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Select which interface triggers the DigitalIn.", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDigitalSourceDefinition, "external_src", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL", "Description", "external_src: of type M2K_TRIGGER_SOURCE_DIGITAL:\n" + newline + ...
    "	 *	SRC_TRIGGER_IN - trigger events on the TI(trigger in) pin trigger the DigitalIn interface;\n" + newline + ...
    "	 *	SRC_ANALOG_IN - trigger events on the AnalogIn interface trigger the DigitalIn interface;\n" + newline + ...
    "	 *	SRC_NONE - trigger events on the DigitalIn are conditioned by the internal digital trigger structure;\n" + newline + ...
    "	 @note Only available from firmware v0.24.");
validate(setDigitalSourceDefinition);

%% C++ class method |getDigitalSource| for C++ class |libm2k::M2kHardwareTrigger|
% C++ Signature: libm2k::M2K_TRIGGER_SOURCE_DIGITAL libm2k::M2kHardwareTrigger::getDigitalSource() const
getDigitalSourceDefinition = addMethod(M2kHardwareTriggerDefinition, ...
    "libm2k::M2K_TRIGGER_SOURCE_DIGITAL libm2k::M2kHardwareTrigger::getDigitalSource() const", ...
    "Description", "clib.libm2k.libm2k.M2kHardwareTrigger.getDigitalSource    Method of C++ class libm2k::M2kHardwareTrigger." + newline + ...
    "Check which is the source of the DigitalIn interface trigger event.", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getDigitalSourceDefinition, "RetVal", "clib.libm2k.libm2k.M2K_TRIGGER_SOURCE_DIGITAL", "Description", "M2K_TRIGGER_SOURCE_DIGITAL :\n" + newline + ...
    "	 *	SRC_TRIGGER_IN;\n" + newline + ...
    "	 *	SRC_ANALOG_IN;\n" + newline + ...
    "	 *	SRC_NONE;\n" + newline + ...
    "	 @note Only available from firmware v0.24.");
validate(getDigitalSourceDefinition);

%% C++ class |libm2k::IIO_OBJECTS| with MATLAB name |clib.libm2k.libm2k.IIO_OBJECTS|
IIO_OBJECTSDefinition = addClass(libDef, "libm2k::IIO_OBJECTS", "MATLABName", "clib.libm2k.libm2k.IIO_OBJECTS", ...
    "Description", "clib.libm2k.libm2k.IIO_OBJECTS    Representation of C++ class libm2k::IIO_OBJECTS.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.

%% C++ class constructor for C++ class |libm2k::IIO_OBJECTS|
% C++ Signature: libm2k::IIO_OBJECTS::IIO_OBJECTS()
IIO_OBJECTSConstructor1Definition = addConstructor(IIO_OBJECTSDefinition, ...
    "libm2k::IIO_OBJECTS::IIO_OBJECTS()", ...
    "Description", "clib.libm2k.libm2k.IIO_OBJECTS.IIO_OBJECTS    Constructor of C++ class libm2k::IIO_OBJECTS."); % Modify help description values as needed.
validate(IIO_OBJECTSConstructor1Definition);

%% C++ class constructor for C++ class |libm2k::IIO_OBJECTS|
% C++ Signature: libm2k::IIO_OBJECTS::IIO_OBJECTS(libm2k::IIO_OBJECTS const & input1)
IIO_OBJECTSConstructor2Definition = addConstructor(IIO_OBJECTSDefinition, ...
    "libm2k::IIO_OBJECTS::IIO_OBJECTS(libm2k::IIO_OBJECTS const & input1)", ...
    "Description", "clib.libm2k.libm2k.IIO_OBJECTS.IIO_OBJECTS    Constructor of C++ class libm2k::IIO_OBJECTS."); % Modify help description values as needed.
defineArgument(IIO_OBJECTSConstructor2Definition, "input1", "clib.libm2k.libm2k.IIO_OBJECTS", "input");
validate(IIO_OBJECTSConstructor2Definition);

%% C++ class public data member |context| for C++ class |libm2k::IIO_OBJECTS|
% C++ Signature: iio_context * libm2k::IIO_OBJECTS::context
%addProperty(IIO_OBJECTSDefinition, "context", "clib.libm2k.iio_context", <SHAPE>, ...
%    "Description", "clib.libm2k.iio_context    Data member of C++ class libm2k::IIO_OBJECTS."); % Modify help description values as needed.

%% C++ class |libm2k::CONTEXT_INFO| with MATLAB name |clib.libm2k.libm2k.CONTEXT_INFO|
CONTEXT_INFODefinition = addClass(libDef, "libm2k::CONTEXT_INFO", "MATLABName", "clib.libm2k.libm2k.CONTEXT_INFO", ...
    "Description", "clib.libm2k.libm2k.CONTEXT_INFO    Representation of C++ class libm2k::CONTEXT_INFO." + newline + ...
    "Additional information about the context", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@struct CONTEXT_INFO" + newline + ...
    "	 @brief Additional information about the context"); % Modify help description values as needed.

%% C++ class constructor for C++ class |libm2k::CONTEXT_INFO|
% C++ Signature: libm2k::CONTEXT_INFO::CONTEXT_INFO()
CONTEXT_INFOConstructor1Definition = addConstructor(CONTEXT_INFODefinition, ...
    "libm2k::CONTEXT_INFO::CONTEXT_INFO()", ...
    "Description", "clib.libm2k.libm2k.CONTEXT_INFO.CONTEXT_INFO    Constructor of C++ class libm2k::CONTEXT_INFO."); % Modify help description values as needed.
validate(CONTEXT_INFOConstructor1Definition);

%% C++ class constructor for C++ class |libm2k::CONTEXT_INFO|
% C++ Signature: libm2k::CONTEXT_INFO::CONTEXT_INFO(libm2k::CONTEXT_INFO const & input1)
CONTEXT_INFOConstructor2Definition = addConstructor(CONTEXT_INFODefinition, ...
    "libm2k::CONTEXT_INFO::CONTEXT_INFO(libm2k::CONTEXT_INFO const & input1)", ...
    "Description", "clib.libm2k.libm2k.CONTEXT_INFO.CONTEXT_INFO    Constructor of C++ class libm2k::CONTEXT_INFO."); % Modify help description values as needed.
defineArgument(CONTEXT_INFOConstructor2Definition, "input1", "clib.libm2k.libm2k.CONTEXT_INFO", "input");
validate(CONTEXT_INFOConstructor2Definition);

%% C++ class public data member |id_vendor| for C++ class |libm2k::CONTEXT_INFO|
% C++ Signature: std::string libm2k::CONTEXT_INFO::id_vendor
addProperty(CONTEXT_INFODefinition, "id_vendor", "string", ...
    "Description", "string    Data member of C++ class libm2k::CONTEXT_INFO." + newline + ...
    "Vendor ID extracted from IIO context"); % Modify help description values as needed.

%% C++ class public data member |id_product| for C++ class |libm2k::CONTEXT_INFO|
% C++ Signature: std::string libm2k::CONTEXT_INFO::id_product
addProperty(CONTEXT_INFODefinition, "id_product", "string", ...
    "Description", "string    Data member of C++ class libm2k::CONTEXT_INFO." + newline + ...
    "Product ID extracted from IIO context"); % Modify help description values as needed.

%% C++ class public data member |manufacturer| for C++ class |libm2k::CONTEXT_INFO|
% C++ Signature: std::string libm2k::CONTEXT_INFO::manufacturer
addProperty(CONTEXT_INFODefinition, "manufacturer", "string", ...
    "Description", "string    Data member of C++ class libm2k::CONTEXT_INFO." + newline + ...
    "Manufacturer extracted from IIO context"); % Modify help description values as needed.

%% C++ class public data member |product| for C++ class |libm2k::CONTEXT_INFO|
% C++ Signature: std::string libm2k::CONTEXT_INFO::product
addProperty(CONTEXT_INFODefinition, "product", "string", ...
    "Description", "string    Data member of C++ class libm2k::CONTEXT_INFO." + newline + ...
    "Product name extracted from IIO context"); % Modify help description values as needed.

%% C++ class public data member |serial| for C++ class |libm2k::CONTEXT_INFO|
% C++ Signature: std::string libm2k::CONTEXT_INFO::serial
addProperty(CONTEXT_INFODefinition, "serial", "string", ...
    "Description", "string    Data member of C++ class libm2k::CONTEXT_INFO." + newline + ...
    "Serial number"); % Modify help description values as needed.

%% C++ class public data member |uri| for C++ class |libm2k::CONTEXT_INFO|
% C++ Signature: std::string libm2k::CONTEXT_INFO::uri
addProperty(CONTEXT_INFODefinition, "uri", "string", ...
    "Description", "string    Data member of C++ class libm2k::CONTEXT_INFO." + newline + ...
    "IIO context URI"); % Modify help description values as needed.

%% C++ enumeration |libm2k::CALIBRATION_MODE| with MATLAB name |clib.libm2k.libm2k.CALIBRATION_MODE|
addEnumeration(libDef, "libm2k::CALIBRATION_MODE", "int32",...
    [...
      "ADC_REF1",...  % 0
      "ADC_REF2",...  % 1
      "ADC_GND",...  % 2
      "DAC",...  % 3
      "NONE",...  % 4
    ],...
    "MATLABName", "clib.libm2k.libm2k.CALIBRATION_MODE", ...
    "Description", "clib.libm2k.libm2k.CALIBRATION_MODE    Representation of C++ enumeration libm2k::CALIBRATION_MODE.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.

%% C++ enumeration |libm2k::GAIN_MODE| with MATLAB name |clib.libm2k.libm2k.GAIN_MODE|
addEnumeration(libDef, "libm2k::GAIN_MODE", "int32",...
    [...
      "LOW_GAIN",...  % 0
      "HIGH_GAIN",...  % 1
    ],...
    "MATLABName", "clib.libm2k.libm2k.GAIN_MODE", ...
    "Description", "clib.libm2k.libm2k.GAIN_MODE    Representation of C++ enumeration libm2k::GAIN_MODE.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.

%% C++ enumeration |libm2k::M2K_EXCEPTION| with MATLAB name |clib.libm2k.libm2k.M2K_EXCEPTION|
addEnumeration(libDef, "libm2k::M2K_EXCEPTION", "int32",...
    [...
      "EXC_OUT_OF_RANGE",...  % 0
      "EXC_RUNTIME_ERROR",...  % 1
      "EXC_INVALID_PARAMETER",...  % 2
      "EXC_TIMEOUT",...  % 3
    ],...
    "MATLABName", "clib.libm2k.libm2k.M2K_EXCEPTION", ...
    "Description", "clib.libm2k.libm2k.M2K_EXCEPTION    Representation of C++ enumeration libm2k::M2K_EXCEPTION.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.

%% C++ class |libm2k::Logger| with MATLAB name |clib.libm2k.libm2k.Logger|
LoggerDefinition = addClass(libDef, "libm2k::Logger", "MATLABName", "clib.libm2k.libm2k.Logger", ...
    "Description", "clib.libm2k.libm2k.Logger    Representation of C++ class libm2k::Logger."); % Modify help description values as needed.

%% C++ class method |getInstance| for C++ class |libm2k::Logger|
% C++ Signature: static libm2k::Logger & libm2k::Logger::getInstance()
getInstanceDefinition = addMethod(LoggerDefinition, ...
    "static libm2k::Logger & libm2k::Logger::getInstance()", ...
    "Description", "clib.libm2k.libm2k.Logger.getInstance    Method of C++ class libm2k::Logger."); % Modify help description values as needed.
defineOutput(getInstanceDefinition, "RetVal", "clib.libm2k.libm2k.Logger");
validate(getInstanceDefinition);

%% C++ class method |warn| for C++ class |libm2k::Logger|
% C++ Signature: void libm2k::Logger::warn(std::string message)
warnDefinition = addMethod(LoggerDefinition, ...
    "void libm2k::Logger::warn(std::string message)", ...
    "Description", "clib.libm2k.libm2k.Logger.warn    Method of C++ class libm2k::Logger."); % Modify help description values as needed.
defineArgument(warnDefinition, "message", "string");
validate(warnDefinition);

%% C++ class constructor for C++ class |libm2k::Logger|
% C++ Signature: libm2k::Logger::Logger(libm2k::Logger const & input1)
LoggerConstructor1Definition = addConstructor(LoggerDefinition, ...
    "libm2k::Logger::Logger(libm2k::Logger const & input1)", ...
    "Description", "clib.libm2k.libm2k.Logger.Logger    Constructor of C++ class libm2k::Logger."); % Modify help description values as needed.
defineArgument(LoggerConstructor1Definition, "input1", "clib.libm2k.libm2k.Logger", "input");
validate(LoggerConstructor1Definition);

%% C++ class |libm2k::M2kCalibration| with MATLAB name |clib.libm2k.libm2k.M2kCalibration|
M2kCalibrationDefinition = addClass(libDef, "libm2k::M2kCalibration", "MATLABName", "clib.libm2k.libm2k.M2kCalibration", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration    Representation of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.

%% C++ class method |initialize| for C++ class |libm2k::M2kCalibration|
% C++ Signature: bool libm2k::M2kCalibration::initialize()
initializeDefinition = addMethod(M2kCalibrationDefinition, ...
    "bool libm2k::M2kCalibration::initialize()", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.initialize    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineOutput(initializeDefinition, "RetVal", "logical");
validate(initializeDefinition);

%% C++ class method |isInitialized| for C++ class |libm2k::M2kCalibration|
% C++ Signature: bool libm2k::M2kCalibration::isInitialized() const
isInitializedDefinition = addMethod(M2kCalibrationDefinition, ...
    "bool libm2k::M2kCalibration::isInitialized() const", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.isInitialized    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineOutput(isInitializedDefinition, "RetVal", "logical");
validate(isInitializedDefinition);

%% C++ class method |calibrateAll| for C++ class |libm2k::M2kCalibration|
% C++ Signature: bool libm2k::M2kCalibration::calibrateAll()
calibrateAllDefinition = addMethod(M2kCalibrationDefinition, ...
    "bool libm2k::M2kCalibration::calibrateAll()", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.calibrateAll    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineOutput(calibrateAllDefinition, "RetVal", "logical");
validate(calibrateAllDefinition);

%% C++ class method |calibrateADC| for C++ class |libm2k::M2kCalibration|
% C++ Signature: bool libm2k::M2kCalibration::calibrateADC()
calibrateADCDefinition = addMethod(M2kCalibrationDefinition, ...
    "bool libm2k::M2kCalibration::calibrateADC()", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.calibrateADC    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineOutput(calibrateADCDefinition, "RetVal", "logical");
validate(calibrateADCDefinition);

%% C++ class method |calibrateDAC| for C++ class |libm2k::M2kCalibration|
% C++ Signature: bool libm2k::M2kCalibration::calibrateDAC()
calibrateDACDefinition = addMethod(M2kCalibrationDefinition, ...
    "bool libm2k::M2kCalibration::calibrateDAC()", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.calibrateDAC    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineOutput(calibrateDACDefinition, "RetVal", "logical");
validate(calibrateDACDefinition);

%% C++ class method |cancelCalibration| for C++ class |libm2k::M2kCalibration|
% C++ Signature: void libm2k::M2kCalibration::cancelCalibration()
cancelCalibrationDefinition = addMethod(M2kCalibrationDefinition, ...
    "void libm2k::M2kCalibration::cancelCalibration()", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.cancelCalibration    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
validate(cancelCalibrationDefinition);

%% C++ class method |getAdcOffset| for C++ class |libm2k::M2kCalibration|
% C++ Signature: int libm2k::M2kCalibration::getAdcOffset(unsigned int channel)
getAdcOffsetDefinition = addMethod(M2kCalibrationDefinition, ...
    "int libm2k::M2kCalibration::getAdcOffset(unsigned int channel)", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.getAdcOffset    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineArgument(getAdcOffsetDefinition, "channel", "uint32");
defineOutput(getAdcOffsetDefinition, "RetVal", "int32");
validate(getAdcOffsetDefinition);

%% C++ class method |getDacOffset| for C++ class |libm2k::M2kCalibration|
% C++ Signature: int libm2k::M2kCalibration::getDacOffset(unsigned int channel)
getDacOffsetDefinition = addMethod(M2kCalibrationDefinition, ...
    "int libm2k::M2kCalibration::getDacOffset(unsigned int channel)", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.getDacOffset    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineArgument(getDacOffsetDefinition, "channel", "uint32");
defineOutput(getDacOffsetDefinition, "RetVal", "int32");
validate(getDacOffsetDefinition);

%% C++ class method |getAdcGain| for C++ class |libm2k::M2kCalibration|
% C++ Signature: double libm2k::M2kCalibration::getAdcGain(unsigned int channel)
getAdcGainDefinition = addMethod(M2kCalibrationDefinition, ...
    "double libm2k::M2kCalibration::getAdcGain(unsigned int channel)", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.getAdcGain    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineArgument(getAdcGainDefinition, "channel", "uint32");
defineOutput(getAdcGainDefinition, "RetVal", "double");
validate(getAdcGainDefinition);

%% C++ class method |getDacGain| for C++ class |libm2k::M2kCalibration|
% C++ Signature: double libm2k::M2kCalibration::getDacGain(unsigned int channel)
getDacGainDefinition = addMethod(M2kCalibrationDefinition, ...
    "double libm2k::M2kCalibration::getDacGain(unsigned int channel)", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.getDacGain    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineArgument(getDacGainDefinition, "channel", "uint32");
defineOutput(getDacGainDefinition, "RetVal", "double");
validate(getDacGainDefinition);

%% C++ class method |resetCalibration| for C++ class |libm2k::M2kCalibration|
% C++ Signature: bool libm2k::M2kCalibration::resetCalibration()
resetCalibrationDefinition = addMethod(M2kCalibrationDefinition, ...
    "bool libm2k::M2kCalibration::resetCalibration()", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.resetCalibration    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineOutput(resetCalibrationDefinition, "RetVal", "logical");
validate(resetCalibrationDefinition);

%% C++ class method |setDacGain| for C++ class |libm2k::M2kCalibration|
% C++ Signature: void libm2k::M2kCalibration::setDacGain(unsigned int chn,double gain)
setDacGainDefinition = addMethod(M2kCalibrationDefinition, ...
    "void libm2k::M2kCalibration::setDacGain(unsigned int chn,double gain)", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.setDacGain    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineArgument(setDacGainDefinition, "chn", "uint32");
defineArgument(setDacGainDefinition, "gain", "double");
validate(setDacGainDefinition);

%% C++ class method |setDacOffset| for C++ class |libm2k::M2kCalibration|
% C++ Signature: void libm2k::M2kCalibration::setDacOffset(unsigned int chn,int offset)
setDacOffsetDefinition = addMethod(M2kCalibrationDefinition, ...
    "void libm2k::M2kCalibration::setDacOffset(unsigned int chn,int offset)", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.setDacOffset    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineArgument(setDacOffsetDefinition, "chn", "uint32");
defineArgument(setDacOffsetDefinition, "offset", "int32");
validate(setDacOffsetDefinition);

%% C++ class method |setAdcOffset| for C++ class |libm2k::M2kCalibration|
% C++ Signature: void libm2k::M2kCalibration::setAdcOffset(unsigned int chn,int offset)
setAdcOffsetDefinition = addMethod(M2kCalibrationDefinition, ...
    "void libm2k::M2kCalibration::setAdcOffset(unsigned int chn,int offset)", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.setAdcOffset    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineArgument(setAdcOffsetDefinition, "chn", "uint32");
defineArgument(setAdcOffsetDefinition, "offset", "int32");
validate(setAdcOffsetDefinition);

%% C++ class method |setAdcGain| for C++ class |libm2k::M2kCalibration|
% C++ Signature: void libm2k::M2kCalibration::setAdcGain(unsigned int chn,double gain)
setAdcGainDefinition = addMethod(M2kCalibrationDefinition, ...
    "void libm2k::M2kCalibration::setAdcGain(unsigned int chn,double gain)", ...
    "Description", "clib.libm2k.libm2k.M2kCalibration.setAdcGain    Method of C++ class libm2k::M2kCalibration."); % Modify help description values as needed.
defineArgument(setAdcGainDefinition, "chn", "uint32");
defineArgument(setAdcGainDefinition, "gain", "double");
validate(setAdcGainDefinition);

%% C++ enumeration |libm2k::digital::DIO_TRIGGER_MODE| with MATLAB name |clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE|
addEnumeration(libDef, "libm2k::digital::DIO_TRIGGER_MODE", "int32",...
    [...
      "DIO_OR",...  % 0
      "DIO_AND",...  % 1
    ],...
    "MATLABName", "clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE", ...
    "Description", "clib.libm2k.libm2k.digital.DIO_TRIGGER_MODE    Representation of C++ enumeration libm2k::digital::DIO_TRIGGER_MODE." + newline + ...
    "Triggering mode for digital channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.

%% C++ enumeration |libm2k::digital::DIO_DIRECTION| with MATLAB name |clib.libm2k.libm2k.digital.DIO_DIRECTION|
addEnumeration(libDef, "libm2k::digital::DIO_DIRECTION", "int32",...
    [...
      "DIO_INPUT",...  % 0
      "DIO_OUTPUT",...  % 1
    ],...
    "MATLABName", "clib.libm2k.libm2k.digital.DIO_DIRECTION", ...
    "Description", "clib.libm2k.libm2k.digital.DIO_DIRECTION    Representation of C++ enumeration libm2k::digital::DIO_DIRECTION." + newline + ...
    "Direction of a digital channel", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@note Digital channels can be used both for transmitting and receiving digital signals"); % Modify help description values as needed.

%% C++ enumeration |libm2k::digital::DIO_CHANNEL| with MATLAB name |clib.libm2k.libm2k.digital.DIO_CHANNEL|
addEnumeration(libDef, "libm2k::digital::DIO_CHANNEL", "int32",...
    [...
      "DIO_CHANNEL_0",...  % 0
      "DIO_CHANNEL_1",...  % 1
      "DIO_CHANNEL_2",...  % 2
      "DIO_CHANNEL_3",...  % 3
      "DIO_CHANNEL_4",...  % 4
      "DIO_CHANNEL_5",...  % 5
      "DIO_CHANNEL_6",...  % 6
      "DIO_CHANNEL_7",...  % 7
      "DIO_CHANNEL_8",...  % 8
      "DIO_CHANNEL_9",...  % 9
      "DIO_CHANNEL_10",...  % 10
      "DIO_CHANNEL_11",...  % 11
      "DIO_CHANNEL_12",...  % 12
      "DIO_CHANNEL_13",...  % 13
      "DIO_CHANNEL_14",...  % 14
      "DIO_CHANNEL_15",...  % 15
    ],...
    "MATLABName", "clib.libm2k.libm2k.digital.DIO_CHANNEL", ...
    "Description", "clib.libm2k.libm2k.digital.DIO_CHANNEL    Representation of C++ enumeration libm2k::digital::DIO_CHANNEL." + newline + ...
    "Indexes of the channels", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@note Each channel can be accessed through its index"); % Modify help description values as needed.

%% C++ enumeration |libm2k::digital::DIO_LEVEL| with MATLAB name |clib.libm2k.libm2k.digital.DIO_LEVEL|
addEnumeration(libDef, "libm2k::digital::DIO_LEVEL", "int32",...
    [...
      "LOW",...  % 0
      "HIGH",...  % 1
    ],...
    "MATLABName", "clib.libm2k.libm2k.digital.DIO_LEVEL", ...
    "Description", "clib.libm2k.libm2k.digital.DIO_LEVEL    Representation of C++ enumeration libm2k::digital::DIO_LEVEL." + newline + ...
    "Logic voltage levels", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@note At any given time a digital signals can only take two possible values, namely low or high"); % Modify help description values as needed.

%% C++ enumeration |libm2k::digital::DIO_MODE| with MATLAB name |clib.libm2k.libm2k.digital.DIO_MODE|
addEnumeration(libDef, "libm2k::digital::DIO_MODE", "int32",...
    [...
      "DIO_OPENDRAIN",...  % 0
      "DIO_PUSHPULL",...  % 1
    ],...
    "MATLABName", "clib.libm2k.libm2k.digital.DIO_MODE", ...
    "Description", "clib.libm2k.libm2k.digital.DIO_MODE    Representation of C++ enumeration libm2k::digital::DIO_MODE." + newline + ...
    "Output mode for a digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.

%% C++ class |libm2k::digital::M2kDigital| with MATLAB name |clib.libm2k.libm2k.digital.M2kDigital|
M2kDigitalDefinition = addClass(libDef, "libm2k::digital::M2kDigital", "MATLABName", "clib.libm2k.libm2k.digital.M2kDigital", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital    Representation of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Contains the representation of the digital segment" + newline + ...
    "" + newline + ...
    "@class M2kDigital" + newline + ...
    "@brief Controls the digital input and output segment", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@defgroup digital Digital" + newline + ...
    "@brief Contains the representation of the digital segment" + newline + ...
    "" + newline + ...
    "@class M2kDigital" + newline + ...
    "@brief Controls the digital input and output segment"); % Modify help description values as needed.

%% C++ class method |reset| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::reset()
resetDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::reset()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.reset    Method of C++ class libm2k::digital::M2kDigital.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(resetDefinition);

%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setDirection(unsigned short mask)
setDirectionDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setDirection(unsigned short mask)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setDirection    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the direction for all digital channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDirectionDefinition, "mask", "uint16", "Description", "mask A bitmask" + newline + ...
    "	@note Each bit of the mask corresponds to the channel with the same index. The value of the bit represents the channel's direction. O - input, 1 - output");
validate(setDirectionDefinition);

%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setDirection(unsigned int index,libm2k::digital::DIO_DIRECTION dir)
setDirectionDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setDirection(unsigned int index,libm2k::digital::DIO_DIRECTION dir)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setDirection    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the direction of the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDirectionDefinition, "index", "uint32", "Description", "index The index corresponding to the channel");
defineArgument(setDirectionDefinition, "dir", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "dir An enumerator that indicates the direction of a channel");
validate(setDirectionDefinition);

%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setDirection(unsigned int index,bool dir)
setDirectionDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setDirection(unsigned int index,bool dir)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setDirection    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the direction of the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDirectionDefinition, "index", "uint32", "Description", "index The index corresponding to the channel");
defineArgument(setDirectionDefinition, "dir", "logical", "Description", "dir A boolean value that corresponds to one direction" + newline + ...
    "	@note The boolean value for input direction is false and for output direction is true");
validate(setDirectionDefinition);

%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,bool dir)
setDirectionDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,bool dir)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setDirection    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the direction of the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDirectionDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index");
defineArgument(setDirectionDefinition, "dir", "logical", "Description", "dir A boolean value that corresponds to one direction" + newline + ...
    "	@note The boolean value for input direction is false and for output direction is true");
validate(setDirectionDefinition);

%% C++ class method |setDirection| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_DIRECTION dir)
setDirectionDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setDirection(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_DIRECTION dir)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setDirection    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the direction of the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDirectionDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index");
defineArgument(setDirectionDefinition, "dir", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "dir An enumerator that indicates the direction of a channel");
validate(setDirectionDefinition);

%% C++ class method |getDirection| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: libm2k::digital::DIO_DIRECTION libm2k::digital::M2kDigital::getDirection(libm2k::digital::DIO_CHANNEL index)
getDirectionDefinition = addMethod(M2kDigitalDefinition, ...
    "libm2k::digital::DIO_DIRECTION libm2k::digital::M2kDigital::getDirection(libm2k::digital::DIO_CHANNEL index)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getDirection    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the direction of the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getDirectionDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index");
defineOutput(getDirectionDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "DIO_DIRECTION An enumerator that indicates the direction of a channel");
validate(getDirectionDefinition);

%% C++ class method |setValueRaw| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_LEVEL level)
setValueRawDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,libm2k::digital::DIO_LEVEL level)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setValueRaw    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the raw value of a given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setValueRawDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index");
defineArgument(setValueRawDefinition, "level", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "level An enumerator corresponding to the raw value");
validate(setValueRawDefinition);

%% C++ class method |push| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::push(std::__1::vector<unsigned short, std::__1::allocator<unsigned short>> const & data)
pushDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::push(std::__1::vector<unsigned short, std::__1::allocator<unsigned short>> const & data)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.push    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Send the samples to all digital channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(pushDefinition, "data", "clib.array.libm2k.UnsignedShort", "Description", "data The std vector that contains the samples");
validate(pushDefinition);

%% C++ class method |push| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::push(unsigned short * data,unsigned int nb_samples)
% pushDefinition = addMethod(M2kDigitalDefinition, ...
%    "void libm2k::digital::M2kDigital::push(unsigned short * data,unsigned int nb_samples)", ...
%    "Description", "clib.libm2k.libm2k.digital.M2kDigital.push    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
%    "Send the samples to all digital channels", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
% defineArgument(pushDefinition, "data", "clib.array.libm2k.UnsignedShort", "input", "nb_samples", "Description", "data a pointer to the samples"); % '<MLTYPE>' can be clib.array.libm2k.UnsignedShort, or uint16
% defineArgument(pushDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples");
% validate(pushDefinition);

%% C++ class method |setValueRaw| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setValueRaw(unsigned int index,libm2k::digital::DIO_LEVEL level)
setValueRawDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setValueRaw(unsigned int index,libm2k::digital::DIO_LEVEL level)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setValueRaw    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the raw value of a given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setValueRawDefinition, "index", "uint32", "Description", "index The index corresponding to the channel");
defineArgument(setValueRawDefinition, "level", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "level An enumerator corresponding to the raw value");
validate(setValueRawDefinition);

%% C++ class method |setValueRaw| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,bool level)
setValueRawDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setValueRaw(libm2k::digital::DIO_CHANNEL index,bool level)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setValueRaw    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the raw value of a given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setValueRawDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index");
defineArgument(setValueRawDefinition, "level", "logical", "Description", "level A boolean value corresponding to the raw value");
validate(setValueRawDefinition);

%% C++ class method |getValueRaw| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(libm2k::digital::DIO_CHANNEL index)
getValueRawDefinition = addMethod(M2kDigitalDefinition, ...
    "libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(libm2k::digital::DIO_CHANNEL index)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getValueRaw    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the raw value of the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getValueRawDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index");
defineOutput(getValueRawDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "DIO_LEVEL An enumerator corresponding to the raw value");
validate(getValueRawDefinition);

%% C++ class method |getValueRaw| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(unsigned int index)
getValueRawDefinition = addMethod(M2kDigitalDefinition, ...
    "libm2k::digital::DIO_LEVEL libm2k::digital::M2kDigital::getValueRaw(unsigned int index)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getValueRaw    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the raw value of the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getValueRawDefinition, "index", "uint32", "Description", "index The index corresponding to the channel");
defineOutput(getValueRawDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_LEVEL", "Description", "DIO_LEVEL An enumerator corresponding to the raw value");
validate(getValueRawDefinition);

%% C++ class method |stopBufferOut| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::stopBufferOut()
stopBufferOutDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::stopBufferOut()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.stopBufferOut    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Stop all digital channels from sending the signals", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@brief Stop all digital channels from sending the signals"); % Modify help description values as needed.
validate(stopBufferOutDefinition);

%% C++ class method |startAcquisition| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::startAcquisition(unsigned int nb_samples)
startAcquisitionDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::startAcquisition(unsigned int nb_samples)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.startAcquisition    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Create the buffer for all channels and start the acquisition", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(startAcquisitionDefinition, "nb_samples", "uint32", "Description", "nb_samples size of the buffer in samples");
validate(startAcquisitionDefinition);

%% C++ class method |stopAcquisition| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::stopAcquisition()
stopAcquisitionDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::stopAcquisition()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.stopAcquisition    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Destroy the buffer and stop the acquisition", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@brief Destroy the buffer and stop the acquisition"); % Modify help description values as needed.
validate(stopAcquisitionDefinition);

%% C++ class method |cancelAcquisition| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::cancelAcquisition()
cancelAcquisitionDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::cancelAcquisition()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.cancelAcquisition    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Cancel all rx-buffer operations" + newline + ...
    "	@note Should be used to cancel an ongoing acquisition", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@brief Cancel all rx-buffer operations" + newline + ...
    "	@note Should be used to cancel an ongoing acquisition"); % Modify help description values as needed.
validate(cancelAcquisitionDefinition);

%% C++ class method |cancelBufferOut| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::cancelBufferOut()
cancelBufferOutDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::cancelBufferOut()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.cancelBufferOut    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Cancel all tx-buffer operations" + newline + ...
    "	@note Should be used to cancel an ongoing data write.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@brief Cancel all tx-buffer operations" + newline + ...
    "	@note Should be used to cancel an ongoing data write."); % Modify help description values as needed.
validate(cancelBufferOutDefinition);

%% C++ class method |getSamples| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: std::__1::vector<unsigned short, std::__1::allocator<unsigned short>> libm2k::digital::M2kDigital::getSamples(unsigned int nb_samples)
getSamplesDefinition = addMethod(M2kDigitalDefinition, ...
    "std::__1::vector<unsigned short, std::__1::allocator<unsigned short>> libm2k::digital::M2kDigital::getSamples(unsigned int nb_samples)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getSamples    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve a specific number of samples", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getSamplesDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved");
defineOutput(getSamplesDefinition, "RetVal", "clib.array.libm2k.UnsignedShort", "Description", "A list that contains the samples");
validate(getSamplesDefinition);

%% C++ class method |getSamplesP| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: unsigned short const * libm2k::digital::M2kDigital::getSamplesP(unsigned int nb_samples)
%getSamplesPDefinition = addMethod(M2kDigitalDefinition, ...
%    "unsigned short const * libm2k::digital::M2kDigital::getSamplesP(unsigned int nb_samples)", ...
%    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getSamplesP    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
%    "Retrieve a specific number of samples", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(getSamplesPDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved");
%defineOutput(getSamplesPDefinition, "RetVal", "clib.array.libm2k.UnsignedShort", <SHAPE>, "Description", "A pointer to the data"); % '<MLTYPE>' can be clib.array.libm2k.UnsignedShort, or uint16
%validate(getSamplesPDefinition);

%% C++ class method |enableChannel| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::enableChannel(unsigned int index,bool enable)
enableChannelDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::enableChannel(unsigned int index,bool enable)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.enableChannel    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Enable or disable the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(enableChannelDefinition, "index", "uint32", "Description", "index The index corresponding to the channel");
defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state");
validate(enableChannelDefinition);

%% C++ class method |enableChannel| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::enableChannel(libm2k::digital::DIO_CHANNEL index,bool enable)
enableChannelDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::enableChannel(libm2k::digital::DIO_CHANNEL index,bool enable)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.enableChannel    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Enable or disable the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(enableChannelDefinition, "index", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "index An enumerator corresponding to the channel's index");
defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state");
validate(enableChannelDefinition);

%% C++ class method |enableAllOut| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::enableAllOut(bool enable)
enableAllOutDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::enableAllOut(bool enable)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.enableAllOut    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Enable or disable all output channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(enableAllOutDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state");
validate(enableAllOutDefinition);

%% C++ class method |anyChannelEnabled| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: bool libm2k::digital::M2kDigital::anyChannelEnabled(libm2k::digital::DIO_DIRECTION dir)
anyChannelEnabledDefinition = addMethod(M2kDigitalDefinition, ...
    "bool libm2k::digital::M2kDigital::anyChannelEnabled(libm2k::digital::DIO_DIRECTION dir)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.anyChannelEnabled    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Check if there is at least one channel enabled", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(anyChannelEnabledDefinition, "dir", "clib.libm2k.libm2k.digital.DIO_DIRECTION", "Description", "dir An enumerator corresponding to the direction of a channel");
defineOutput(anyChannelEnabledDefinition, "RetVal", "logical", "Description", "On succces, true");
validate(anyChannelEnabledDefinition);

%% C++ class method |setOutputMode| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setOutputMode(libm2k::digital::DIO_CHANNEL chn,libm2k::digital::DIO_MODE mode)
setOutputModeDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setOutputMode(libm2k::digital::DIO_CHANNEL chn,libm2k::digital::DIO_MODE mode)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setOutputMode    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the output mode for the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setOutputModeDefinition, "chn", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "chn An enumerator corresponding to the channel's index");
defineArgument(setOutputModeDefinition, "mode", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "mode An enumerator corresponding to the output mode");
validate(setOutputModeDefinition);

%% C++ class method |setOutputMode| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setOutputMode(unsigned int chn,libm2k::digital::DIO_MODE mode)
setOutputModeDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setOutputMode(unsigned int chn,libm2k::digital::DIO_MODE mode)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setOutputMode    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the output mode for the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setOutputModeDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineArgument(setOutputModeDefinition, "mode", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "mode An enumerator corresponding to the output mode");
validate(setOutputModeDefinition);

%% C++ class method |getOutputMode| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(libm2k::digital::DIO_CHANNEL chn)
getOutputModeDefinition = addMethod(M2kDigitalDefinition, ...
    "libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(libm2k::digital::DIO_CHANNEL chn)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getOutputMode    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the output mode for the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getOutputModeDefinition, "chn", "clib.libm2k.libm2k.digital.DIO_CHANNEL", "Description", "chn An enumerator corresponding to the channel's index");
defineOutput(getOutputModeDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "An enumerator corresponding to the output mode");
validate(getOutputModeDefinition);

%% C++ class method |getOutputMode| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(unsigned int chn)
getOutputModeDefinition = addMethod(M2kDigitalDefinition, ...
    "libm2k::digital::DIO_MODE libm2k::digital::M2kDigital::getOutputMode(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getOutputMode    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the output mode for the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getOutputModeDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineOutput(getOutputModeDefinition, "RetVal", "clib.libm2k.libm2k.digital.DIO_MODE", "Description", "An enumerator corresponding to the output mode");
validate(getOutputModeDefinition);

%% C++ class method |setSampleRateIn| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: double libm2k::digital::M2kDigital::setSampleRateIn(double samplerate)
setSampleRateInDefinition = addMethod(M2kDigitalDefinition, ...
    "double libm2k::digital::M2kDigital::setSampleRateIn(double samplerate)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setSampleRateIn    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the sample rate for all digital input channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setSampleRateInDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to");
defineOutput(setSampleRateInDefinition, "RetVal", "double", "Description", "The current sample rate for all digital input channels");
validate(setSampleRateInDefinition);

%% C++ class method |setSampleRateOut| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: double libm2k::digital::M2kDigital::setSampleRateOut(double samplerate)
setSampleRateOutDefinition = addMethod(M2kDigitalDefinition, ...
    "double libm2k::digital::M2kDigital::setSampleRateOut(double samplerate)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setSampleRateOut    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the sample rate for all digital output channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setSampleRateOutDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to");
defineOutput(setSampleRateOutDefinition, "RetVal", "double", "Description", "The current sample rate for all digital output channels");
validate(setSampleRateOutDefinition);

%% C++ class method |getSampleRateIn| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: double libm2k::digital::M2kDigital::getSampleRateIn()
getSampleRateInDefinition = addMethod(M2kDigitalDefinition, ...
    "double libm2k::digital::M2kDigital::getSampleRateIn()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getSampleRateIn    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the sample rate of all digital input channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getSampleRateInDefinition, "RetVal", "double", "Description", "The value of the sample rate");
validate(getSampleRateInDefinition);

%% C++ class method |getSampleRateOut| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: double libm2k::digital::M2kDigital::getSampleRateOut()
getSampleRateOutDefinition = addMethod(M2kDigitalDefinition, ...
    "double libm2k::digital::M2kDigital::getSampleRateOut()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getSampleRateOut    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the sample rate of all digital output channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getSampleRateOutDefinition, "RetVal", "double", "Description", "The value of the sample rate");
validate(getSampleRateOutDefinition);

%% C++ class method |getCyclic| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: bool libm2k::digital::M2kDigital::getCyclic()
getCyclicDefinition = addMethod(M2kDigitalDefinition, ...
    "bool libm2k::digital::M2kDigital::getCyclic()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getCyclic    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the value of the cyclic mode", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getCyclicDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the cyclic mode");
validate(getCyclicDefinition);

%% C++ class method |setCyclic| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setCyclic(bool cyclic)
setCyclicDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setCyclic(bool cyclic)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setCyclic    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Enable or disable the cyclic mode for all digital channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setCyclicDefinition, "cyclic", "logical", "Description", "cyclic If true, enable cyclic mode");
validate(setCyclicDefinition);

%% C++ class method |getTrigger| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: libm2k::M2kHardwareTrigger * libm2k::digital::M2kDigital::getTrigger()
getTriggerDefinition = addMethod(M2kDigitalDefinition, ...
   "libm2k::M2kHardwareTrigger * libm2k::digital::M2kDigital::getTrigger()", ...
   "Description", "clib.libm2k.libm2k.digital.M2kDigital.getTrigger    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
   "Get the hardware trigger handler", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getTriggerDefinition, "RetVal", "clib.libm2k.libm2k.M2kHardwareTrigger", 1, "Description", "the trigger object"); % '<MLTYPE>' can be clib.libm2k.libm2k.M2kHardwareTrigger, or clib.array.libm2k.libm2k.M2kHardwareTrigger
validate(getTriggerDefinition);

%% C++ class method |setKernelBuffersCountIn| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setKernelBuffersCountIn(unsigned int count)
setKernelBuffersCountInDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setKernelBuffersCountIn(unsigned int count)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setKernelBuffersCountIn    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the kernel buffers for input to a specific value", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setKernelBuffersCountInDefinition, "count", "uint32", "Description", "count the number of kernel buffers");
validate(setKernelBuffersCountInDefinition);

%% C++ class method |setKernelBuffersCountOut| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::setKernelBuffersCountOut(unsigned int count)
setKernelBuffersCountOutDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::setKernelBuffersCountOut(unsigned int count)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.setKernelBuffersCountOut    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Set the kernel buffers for output to a specific value", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setKernelBuffersCountOutDefinition, "count", "uint32", "Description", "count the number of kernel buffers");
validate(setKernelBuffersCountOutDefinition);

%% C++ class method |getIioObjects| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: libm2k::IIO_OBJECTS libm2k::digital::M2kDigital::getIioObjects()
getIioObjectsDefinition = addMethod(M2kDigitalDefinition, ...
    "libm2k::IIO_OBJECTS libm2k::digital::M2kDigital::getIioObjects()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getIioObjects    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Get access to IIO channels, buffers, devices and context." + newline + ...
    "	 Can be used when debugging directly with libiio.", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getIioObjectsDefinition, "RetVal", "clib.libm2k.libm2k.IIO_OBJECTS", "Description", "IIO_OBJECTS structure.");
validate(getIioObjectsDefinition);

%% C++ class method |getNbChannelsIn| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: unsigned int libm2k::digital::M2kDigital::getNbChannelsIn()
getNbChannelsInDefinition = addMethod(M2kDigitalDefinition, ...
    "unsigned int libm2k::digital::M2kDigital::getNbChannelsIn()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getNbChannelsIn    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the number of digital input channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getNbChannelsInDefinition, "RetVal", "uint32", "Description", "an unsigned int representing the number of digital IN channels");
validate(getNbChannelsInDefinition);

%% C++ class method |getNbChannelsOut| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: unsigned int libm2k::digital::M2kDigital::getNbChannelsOut()
getNbChannelsOutDefinition = addMethod(M2kDigitalDefinition, ...
    "unsigned int libm2k::digital::M2kDigital::getNbChannelsOut()", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getNbChannelsOut    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve the number of digital output channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getNbChannelsOutDefinition, "RetVal", "uint32", "Description", "an unsigned int representing the number of digital OUT channels");
validate(getNbChannelsOutDefinition);

%% C++ class method |getSamples| for C++ class |libm2k::digital::M2kDigital|
% C++ Signature: void libm2k::digital::M2kDigital::getSamples(std::__1::vector<unsigned short, std::__1::allocator<unsigned short>> & data,unsigned int nb_samples)
getSamplesDefinition = addMethod(M2kDigitalDefinition, ...
    "void libm2k::digital::M2kDigital::getSamples(std::__1::vector<unsigned short, std::__1::allocator<unsigned short>> & data,unsigned int nb_samples)", ...
    "Description", "clib.libm2k.libm2k.digital.M2kDigital.getSamples    Method of C++ class libm2k::digital::M2kDigital." + newline + ...
    "Retrieve a specific number of samples", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getSamplesDefinition, "data", "clib.array.libm2k.UnsignedShort", "Description", "data - a reference to a vector owned/created by the client");
defineArgument(getSamplesDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved. The vector will be cleaned and then filled with samples.");
validate(getSamplesDefinition);

%% C++ class |libm2k::digital::channel| with MATLAB name |clib.libm2k.libm2k.digital.channel|
channelDefinition = addClass(libDef, "libm2k::digital::channel", "MATLABName", "clib.libm2k.libm2k.digital.channel", ...
    "Description", "clib.libm2k.libm2k.digital.channel    Representation of C++ class libm2k::digital::channel.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.

%% C++ class constructor for C++ class |libm2k::digital::channel|
% C++ Signature: libm2k::digital::channel::channel()
channelConstructor1Definition = addConstructor(channelDefinition, ...
    "libm2k::digital::channel::channel()", ...
    "Description", "clib.libm2k.libm2k.digital.channel.channel    Constructor of C++ class libm2k::digital::channel."); % Modify help description values as needed.
validate(channelConstructor1Definition);

%% C++ class constructor for C++ class |libm2k::digital::channel|
% C++ Signature: libm2k::digital::channel::channel(libm2k::digital::channel const & input1)
channelConstructor2Definition = addConstructor(channelDefinition, ...
    "libm2k::digital::channel::channel(libm2k::digital::channel const & input1)", ...
    "Description", "clib.libm2k.libm2k.digital.channel.channel    Constructor of C++ class libm2k::digital::channel."); % Modify help description values as needed.
defineArgument(channelConstructor2Definition, "input1", "clib.libm2k.libm2k.digital.channel", "input");
validate(channelConstructor2Definition);

%% C++ class public data member |m_channel| for C++ class |libm2k::digital::channel|
% C++ Signature: iio_channel * libm2k::digital::channel::m_channel
%addProperty(channelDefinition, "m_channel", "clib.libm2k.iio_channel", <SHAPE>, ...
%    "Description", "clib.libm2k.iio_channel    Data member of C++ class libm2k::digital::channel." + newline + ...
%    "A pointer to an iio_channel structure"); % Modify help description values as needed.

%% C++ class public data member |m_direction| for C++ class |libm2k::digital::channel|
% C++ Signature: libm2k::digital::DIO_DIRECTION libm2k::digital::channel::m_direction
addProperty(channelDefinition, "m_direction", "clib.libm2k.libm2k.digital.DIO_DIRECTION", ...
    "Description", "clib.libm2k.libm2k.digital.DIO_DIRECTION    Data member of C++ class libm2k::digital::channel." + newline + ...
    "The direction of the channel"); % Modify help description values as needed.

%% C++ class |libm2k::utils::ini_device_struct| with MATLAB name |clib.libm2k.libm2k.utils.ini_device_struct|
ini_device_structDefinition = addClass(libDef, "libm2k::utils::ini_device_struct", "MATLABName", "clib.libm2k.libm2k.utils.ini_device_struct", ...
    "Description", "clib.libm2k.libm2k.utils.ini_device_struct    Representation of C++ class libm2k::utils::ini_device_struct."); % Modify help description values as needed.

%% C++ class constructor for C++ class |libm2k::utils::ini_device_struct|
% C++ Signature: libm2k::utils::ini_device_struct::ini_device_struct()
ini_device_structConstructor1Definition = addConstructor(ini_device_structDefinition, ...
    "libm2k::utils::ini_device_struct::ini_device_struct()", ...
    "Description", "clib.libm2k.libm2k.utils.ini_device_struct.ini_device_struct    Constructor of C++ class libm2k::utils::ini_device_struct."); % Modify help description values as needed.
validate(ini_device_structConstructor1Definition);

%% C++ class constructor for C++ class |libm2k::utils::ini_device_struct|
% C++ Signature: libm2k::utils::ini_device_struct::ini_device_struct(libm2k::utils::ini_device_struct const & input1)
ini_device_structConstructor2Definition = addConstructor(ini_device_structDefinition, ...
    "libm2k::utils::ini_device_struct::ini_device_struct(libm2k::utils::ini_device_struct const & input1)", ...
    "Description", "clib.libm2k.libm2k.utils.ini_device_struct.ini_device_struct    Constructor of C++ class libm2k::utils::ini_device_struct."); % Modify help description values as needed.
defineArgument(ini_device_structConstructor2Definition, "input1", "clib.libm2k.libm2k.utils.ini_device_struct", "input");
validate(ini_device_structConstructor2Definition);

%% C++ class public data member |hw_name| for C++ class |libm2k::utils::ini_device_struct|
% C++ Signature: std::string libm2k::utils::ini_device_struct::hw_name
addProperty(ini_device_structDefinition, "hw_name", "string", ...
    "Description", "string    Data member of C++ class libm2k::utils::ini_device_struct."); % Modify help description values as needed.

%% C++ enumeration |libm2k::utils::DEVICE_TYPE| with MATLAB name |clib.libm2k.libm2k.utils.DEVICE_TYPE|
addEnumeration(libDef, "libm2k::utils::DEVICE_TYPE", "int32",...
    [...
      "ANALOG_DEV",...  % 1
      "DIGITAL_DEV",...  % 2
      "NO_DEV",...  % 3
    ],...
    "MATLABName", "clib.libm2k.libm2k.utils.DEVICE_TYPE", ...
    "Description", "clib.libm2k.libm2k.utils.DEVICE_TYPE    Representation of C++ enumeration libm2k::utils::DEVICE_TYPE."); % Modify help description values as needed.

%% C++ enumeration |libm2k::utils::DEVICE_DIRECTION| with MATLAB name |clib.libm2k.libm2k.utils.DEVICE_DIRECTION|
addEnumeration(libDef, "libm2k::utils::DEVICE_DIRECTION", "int32",...
    [...
      "INPUT",...  % 1
      "OUTPUT",...  % 2
      "BOTH",...  % 3
      "NO_DIRECTION",...  % 4
    ],...
    "MATLABName", "clib.libm2k.libm2k.utils.DEVICE_DIRECTION", ...
    "Description", "clib.libm2k.libm2k.utils.DEVICE_DIRECTION    Representation of C++ enumeration libm2k::utils::DEVICE_DIRECTION."); % Modify help description values as needed.

%% C++ class |libm2k::utils::Utils| with MATLAB name |clib.libm2k.libm2k.utils.Utils|
UtilsDefinition = addClass(libDef, "libm2k::utils::Utils", "MATLABName", "clib.libm2k.libm2k.utils.Utils", ...
    "Description", "clib.libm2k.libm2k.utils.Utils    Representation of C++ class libm2k::utils::Utils."); % Modify help description values as needed.

%% C++ class constructor for C++ class |libm2k::utils::Utils|
% C++ Signature: libm2k::utils::Utils::Utils()
UtilsConstructor1Definition = addConstructor(UtilsDefinition, ...
    "libm2k::utils::Utils::Utils()", ...
    "Description", "clib.libm2k.libm2k.utils.Utils.Utils    Constructor of C++ class libm2k::utils::Utils."); % Modify help description values as needed.
validate(UtilsConstructor1Definition);

%% C++ class method |parseIniFile| for C++ class |libm2k::utils::Utils|
% C++ Signature: static std::__1::vector<libm2k::utils::ini_device_struct, std::__1::allocator<libm2k::utils::ini_device_struct>> libm2k::utils::Utils::parseIniFile(std::string path)
parseIniFileDefinition = addMethod(UtilsDefinition, ...
    "static std::__1::vector<libm2k::utils::ini_device_struct, std::__1::allocator<libm2k::utils::ini_device_struct>> libm2k::utils::Utils::parseIniFile(std::string path)", ...
    "Description", "clib.libm2k.libm2k.utils.Utils.parseIniFile    Method of C++ class libm2k::utils::Utils." + newline + ...
    "Utils::getIioDevByChannelAttrs", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(parseIniFileDefinition, "path", "string", "Description", "ctx : iio_context");
defineOutput(parseIniFileDefinition, "RetVal", "clib.array.libm2k.libm2k.utils.ini_device_struct", "Description", "A list of pairs of type <device_name, channel_name> which have" + newline + ...
    "		 all the required attributes as channel attributes for the <channel_name>." + newline + ...
    "		 The list can also contain pairs of type <device_name, """">, which means" + newline + ...
    "		 all the required attributes were found as global attributes for the device <device_name>.");
validate(parseIniFileDefinition);

%% C++ class method |getHardwareRevision| for C++ class |libm2k::utils::Utils|
% C++ Signature: static std::string libm2k::utils::Utils::getHardwareRevision(iio_context * ctx)
%getHardwareRevisionDefinition = addMethod(UtilsDefinition, ...
%    "static std::string libm2k::utils::Utils::getHardwareRevision(iio_context * ctx)", ...
%    "Description", "clib.libm2k.libm2k.utils.Utils.getHardwareRevision    Method of C++ class libm2k::utils::Utils."); % Modify help description values as needed.
%defineArgument(getHardwareRevisionDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>);
%defineOutput(getHardwareRevisionDefinition, "RetVal", "string");
%validate(getHardwareRevisionDefinition);

%% C++ class method |getFirmwareVersion| for C++ class |libm2k::utils::Utils|
% C++ Signature: static std::string libm2k::utils::Utils::getFirmwareVersion(iio_context * ctx)
%getFirmwareVersionDefinition = addMethod(UtilsDefinition, ...
%    "static std::string libm2k::utils::Utils::getFirmwareVersion(iio_context * ctx)", ...
%    "Description", "clib.libm2k.libm2k.utils.Utils.getFirmwareVersion    Method of C++ class libm2k::utils::Utils."); % Modify help description values as needed.
%defineArgument(getFirmwareVersionDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>);
%defineOutput(getFirmwareVersionDefinition, "RetVal", "string");
%validate(getFirmwareVersionDefinition);

%% C++ class method |average| for C++ class |libm2k::utils::Utils|
% C++ Signature: static double libm2k::utils::Utils::average(double * data,size_t numElements)
%averageDefinition = addMethod(UtilsDefinition, ...
%    "static double libm2k::utils::Utils::average(double * data,size_t numElements)", ...
%    "Description", "clib.libm2k.libm2k.utils.Utils.average    Method of C++ class libm2k::utils::Utils."); % Modify help description values as needed.
%defineArgument(averageDefinition, "data", "clib.array.libm2k.Double", "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Double, or double
%defineArgument(averageDefinition, "numElements", "uint64");
%defineOutput(averageDefinition, "RetVal", "double");
%validate(averageDefinition);

%% C++ class method |getAvailableSamplerates| for C++ class |libm2k::utils::Utils|
% C++ Signature: static std::__1::vector<double, std::__1::allocator<double>> libm2k::utils::Utils::getAvailableSamplerates(iio_device * input1)
%getAvailableSampleratesDefinition = addMethod(UtilsDefinition, ...
%    "static std::__1::vector<double, std::__1::allocator<double>> libm2k::utils::Utils::getAvailableSamplerates(iio_device * input1)", ...
%    "Description", "clib.libm2k.libm2k.utils.Utils.getAvailableSamplerates    Method of C++ class libm2k::utils::Utils."); % Modify help description values as needed.
%defineArgument(getAvailableSampleratesDefinition, "input1", "clib.libm2k.iio_device", "input", <SHAPE>);
%defineOutput(getAvailableSampleratesDefinition, "RetVal", "clib.array.libm2k.Double");
%validate(getAvailableSampleratesDefinition);

%% C++ class method |getIioDeviceDirection| for C++ class |libm2k::utils::Utils|
% C++ Signature: static libm2k::utils::DEVICE_DIRECTION libm2k::utils::Utils::getIioDeviceDirection(iio_device * dev)
%getIioDeviceDirectionDefinition = addMethod(UtilsDefinition, ...
%    "static libm2k::utils::DEVICE_DIRECTION libm2k::utils::Utils::getIioDeviceDirection(iio_device * dev)", ...
%    "Description", "clib.libm2k.libm2k.utils.Utils.getIioDeviceDirection    Method of C++ class libm2k::utils::Utils."); % Modify help description values as needed.
%defineArgument(getIioDeviceDirectionDefinition, "dev", "clib.libm2k.iio_device", "input", <SHAPE>);
%defineOutput(getIioDeviceDirectionDefinition, "RetVal", "clib.libm2k.libm2k.utils.DEVICE_DIRECTION");
%validate(getIioDeviceDirectionDefinition);

%% C++ class method |compareVersions| for C++ class |libm2k::utils::Utils|
% C++ Signature: static int libm2k::utils::Utils::compareVersions(std::string v1,std::string v2)
compareVersionsDefinition = addMethod(UtilsDefinition, ...
    "static int libm2k::utils::Utils::compareVersions(std::string v1,std::string v2)", ...
    "Description", "clib.libm2k.libm2k.utils.Utils.compareVersions    Method of C++ class libm2k::utils::Utils."); % Modify help description values as needed.
defineArgument(compareVersionsDefinition, "v1", "string");
defineArgument(compareVersionsDefinition, "v2", "string");
defineOutput(compareVersionsDefinition, "RetVal", "int32");
validate(compareVersionsDefinition);

%% C++ class method |compareNatural| for C++ class |libm2k::utils::Utils|
% C++ Signature: static bool libm2k::utils::Utils::compareNatural(std::string const & a,std::string const & b)
compareNaturalDefinition = addMethod(UtilsDefinition, ...
    "static bool libm2k::utils::Utils::compareNatural(std::string const & a,std::string const & b)", ...
    "Description", "clib.libm2k.libm2k.utils.Utils.compareNatural    Method of C++ class libm2k::utils::Utils."); % Modify help description values as needed.
defineArgument(compareNaturalDefinition, "a", "string", "input");
defineArgument(compareNaturalDefinition, "b", "string", "input");
defineOutput(compareNaturalDefinition, "RetVal", "logical");
validate(compareNaturalDefinition);

%% C++ class constructor for C++ class |libm2k::utils::Utils|
% C++ Signature: libm2k::utils::Utils::Utils(libm2k::utils::Utils const & input1)
UtilsConstructor2Definition = addConstructor(UtilsDefinition, ...
    "libm2k::utils::Utils::Utils(libm2k::utils::Utils const & input1)", ...
    "Description", "clib.libm2k.libm2k.utils.Utils.Utils    Constructor of C++ class libm2k::utils::Utils."); % Modify help description values as needed.
defineArgument(UtilsConstructor2Definition, "input1", "clib.libm2k.libm2k.utils.Utils", "input");
validate(UtilsConstructor2Definition);

%% C++ class |libm2k::analog::DMM_READING| with MATLAB name |clib.libm2k.libm2k.analog.DMM_READING|
DMM_READINGDefinition = addClass(libDef, "libm2k::analog::DMM_READING", "MATLABName", "clib.libm2k.libm2k.analog.DMM_READING", ...
    "Description", "clib.libm2k.libm2k.analog.DMM_READING    Representation of C++ class libm2k::analog::DMM_READING." + newline + ...
    "The structure of a DMM", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.

%% C++ class constructor for C++ class |libm2k::analog::DMM_READING|
% C++ Signature: libm2k::analog::DMM_READING::DMM_READING()
DMM_READINGConstructor1Definition = addConstructor(DMM_READINGDefinition, ...
    "libm2k::analog::DMM_READING::DMM_READING()", ...
    "Description", "clib.libm2k.libm2k.analog.DMM_READING.DMM_READING    Constructor of C++ class libm2k::analog::DMM_READING."); % Modify help description values as needed.
validate(DMM_READINGConstructor1Definition);

%% C++ class constructor for C++ class |libm2k::analog::DMM_READING|
% C++ Signature: libm2k::analog::DMM_READING::DMM_READING(libm2k::analog::DMM_READING const & input1)
DMM_READINGConstructor2Definition = addConstructor(DMM_READINGDefinition, ...
    "libm2k::analog::DMM_READING::DMM_READING(libm2k::analog::DMM_READING const & input1)", ...
    "Description", "clib.libm2k.libm2k.analog.DMM_READING.DMM_READING    Constructor of C++ class libm2k::analog::DMM_READING."); % Modify help description values as needed.
defineArgument(DMM_READINGConstructor2Definition, "input1", "clib.libm2k.libm2k.analog.DMM_READING", "input");
validate(DMM_READINGConstructor2Definition);

%% C++ class public data member |name| for C++ class |libm2k::analog::DMM_READING|
% C++ Signature: std::string libm2k::analog::DMM_READING::name
addProperty(DMM_READINGDefinition, "name", "string", ...
    "Description", "string    Data member of C++ class libm2k::analog::DMM_READING." + newline + ...
    "The name of the channel"); % Modify help description values as needed.

%% C++ class public data member |id| for C++ class |libm2k::analog::DMM_READING|
% C++ Signature: std::string libm2k::analog::DMM_READING::id
addProperty(DMM_READINGDefinition, "id", "string", ...
    "Description", "string    Data member of C++ class libm2k::analog::DMM_READING." + newline + ...
    "Channel's id"); % Modify help description values as needed.

%% C++ class public data member |value| for C++ class |libm2k::analog::DMM_READING|
% C++ Signature: double libm2k::analog::DMM_READING::value
addProperty(DMM_READINGDefinition, "value", "double", ...
    "Description", "double    Data member of C++ class libm2k::analog::DMM_READING." + newline + ...
    "The measured value"); % Modify help description values as needed.

%% C++ class public data member |unit| for C++ class |libm2k::analog::DMM_READING|
% C++ Signature: std::string libm2k::analog::DMM_READING::unit
addProperty(DMM_READINGDefinition, "unit", "string", ...
    "Description", "string    Data member of C++ class libm2k::analog::DMM_READING." + newline + ...
    "Unit of measurement"); % Modify help description values as needed.

%% C++ class |libm2k::analog::DMM| with MATLAB name |clib.libm2k.libm2k.analog.DMM|
DMMDefinition = addClass(libDef, "libm2k::analog::DMM", "MATLABName", "clib.libm2k.libm2k.analog.DMM", ...
    "Description", "clib.libm2k.libm2k.analog.DMM    Representation of C++ class libm2k::analog::DMM." + newline + ...
    "Contains the representation of the digital multimeter" + newline + ...
    "" + newline + ...
    "@class DMM" + newline + ...
    "@brief Controls the digital multimeter", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@defgroup dmm DMM" + newline + ...
    "@brief Contains the representation of the digital multimeter" + newline + ...
    "" + newline + ...
    "@class DMM" + newline + ...
    "@brief Controls the digital multimeter"); % Modify help description values as needed.

%% C++ class method |reset| for C++ class |libm2k::analog::DMM|
% C++ Signature: void libm2k::analog::DMM::reset()
resetDefinition = addMethod(DMMDefinition, ...
    "void libm2k::analog::DMM::reset()", ...
    "Description", "clib.libm2k.libm2k.analog.DMM.reset    Method of C++ class libm2k::analog::DMM.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(resetDefinition);

%% C++ class method |readChannel| for C++ class |libm2k::analog::DMM|
% C++ Signature: libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(unsigned int index)
readChannelDefinition = addMethod(DMMDefinition, ...
    "libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(unsigned int index)", ...
    "Description", "clib.libm2k.libm2k.analog.DMM.readChannel    Method of C++ class libm2k::analog::DMM." + newline + ...
    "Retrieve additional information about the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(readChannelDefinition, "index", "uint32", "Description", "index The index corresponding to the channel");
defineOutput(readChannelDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM_READING", "Description", "A structure containing additional information");
validate(readChannelDefinition);

%% C++ class method |readChannel| for C++ class |libm2k::analog::DMM|
% C++ Signature: libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(std::string chn_name)
readChannelDefinition = addMethod(DMMDefinition, ...
    "libm2k::analog::DMM_READING libm2k::analog::DMM::readChannel(std::string chn_name)", ...
    "Description", "clib.libm2k.libm2k.analog.DMM.readChannel    Method of C++ class libm2k::analog::DMM." + newline + ...
    "Retrieve additional information about the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(readChannelDefinition, "chn_name", "string", "Description", "chn_name The name corresponding to the channel");
defineOutput(readChannelDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM_READING", "Description", "A structure containing additional information");
validate(readChannelDefinition);

%% C++ class method |readAll| for C++ class |libm2k::analog::DMM|
% C++ Signature: std::__1::vector<libm2k::analog::DMM_READING, std::__1::allocator<libm2k::analog::DMM_READING>> libm2k::analog::DMM::readAll()
readAllDefinition = addMethod(DMMDefinition, ...
    "std::__1::vector<libm2k::analog::DMM_READING, std::__1::allocator<libm2k::analog::DMM_READING>> libm2k::analog::DMM::readAll()", ...
    "Description", "clib.libm2k.libm2k.analog.DMM.readAll    Method of C++ class libm2k::analog::DMM." + newline + ...
    "Retrieve additional information about all channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(readAllDefinition, "RetVal", "clib.array.libm2k.libm2k.analog.DMM_READING", "Description", "A list containing structures for each channel");
validate(readAllDefinition);

%% C++ class method |getName| for C++ class |libm2k::analog::DMM|
% C++ Signature: std::string libm2k::analog::DMM::getName()
getNameDefinition = addMethod(DMMDefinition, ...
    "std::string libm2k::analog::DMM::getName()", ...
    "Description", "clib.libm2k.libm2k.analog.DMM.getName    Method of C++ class libm2k::analog::DMM." + newline + ...
    "Retrieve the device's name", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getNameDefinition, "RetVal", "string", "Description", "The name of the device");
validate(getNameDefinition);

%% C++ enumeration |libm2k::analog::ANALOG_IN_CHANNEL| with MATLAB name |clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL|
addEnumeration(libDef, "libm2k::analog::ANALOG_IN_CHANNEL", "int32",...
    [...
      "ANALOG_IN_CHANNEL_1",...  % 0
      "ANALOG_IN_CHANNEL_2",...  % 1
    ],...
    "MATLABName", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", ...
    "Description", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL    Representation of C++ enumeration libm2k::analog::ANALOG_IN_CHANNEL." + newline + ...
    "Indexes of the channels", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@note Each channel can be accessed through its index"); % Modify help description values as needed.

%% C++ enumeration |libm2k::analog::M2K_RANGE| with MATLAB name |clib.libm2k.libm2k.analog.M2K_RANGE|
addEnumeration(libDef, "libm2k::analog::M2K_RANGE", "int32",...
    [...
      "PLUS_MINUS_25V",...  % 0
      "PLUS_MINUS_2_5V",...  % 1
    ],...
    "MATLABName", "clib.libm2k.libm2k.analog.M2K_RANGE", ...
    "Description", "clib.libm2k.libm2k.analog.M2K_RANGE    Representation of C++ enumeration libm2k::analog::M2K_RANGE." + newline + ...
    "Range of the signal's amplitude", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.

%% C++ class |libm2k::analog::M2kAnalogIn| with MATLAB name |clib.libm2k.libm2k.analog.M2kAnalogIn|
M2kAnalogInDefinition = addClass(libDef, "libm2k::analog::M2kAnalogIn", "MATLABName", "clib.libm2k.libm2k.analog.M2kAnalogIn", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn    Representation of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Contains the representation of the analogical input segment" + newline + ...
    "" + newline + ...
    "@class M2kAnalogIn" + newline + ...
    "@brief Controls the analogical input compound", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@defgroup analogin AnalogIn" + newline + ...
    "@brief Contains the representation of the analogical input segment" + newline + ...
    "" + newline + ...
    "@class M2kAnalogIn" + newline + ...
    "@brief Controls the analogical input compound"); % Modify help description values as needed.

%% C++ class method |reset| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: void libm2k::analog::M2kAnalogIn::reset()
resetDefinition = addMethod(M2kAnalogInDefinition, ...
    "void libm2k::analog::M2kAnalogIn::reset()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.reset    Method of C++ class libm2k::analog::M2kAnalogIn.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(resetDefinition);

%% C++ class method |startAcquisition| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: void libm2k::analog::M2kAnalogIn::startAcquisition(unsigned int nb_samples)
startAcquisitionDefinition = addMethod(M2kAnalogInDefinition, ...
    "void libm2k::analog::M2kAnalogIn::startAcquisition(unsigned int nb_samples)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.startAcquisition    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Create the buffer for both channels and start the acquisition", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(startAcquisitionDefinition, "nb_samples", "uint32", "Description", "nb_samples size of the buffer in samples for each channel");
validate(startAcquisitionDefinition);

%% C++ class method |stopAcquisition| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: void libm2k::analog::M2kAnalogIn::stopAcquisition()
stopAcquisitionDefinition = addMethod(M2kAnalogInDefinition, ...
    "void libm2k::analog::M2kAnalogIn::stopAcquisition()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.stopAcquisition    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Destroy the buffer and stop the acquisition", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@brief Destroy the buffer and stop the acquisition"); % Modify help description values as needed.
validate(stopAcquisitionDefinition);

%% C++ class method |getSamplesInterleaved| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved(unsigned int nb_samples)
getSamplesInterleavedDefinition = addMethod(M2kAnalogInDefinition, ...
   "double const * libm2k::analog::M2kAnalogIn::getSamplesInterleaved(unsigned int nb_samples)", ...
   "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getSamplesInterleaved    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
   "Retrieve a specific number of samples from both channels", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getSamplesInterleavedDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved");
defineOutput(getSamplesInterleavedDefinition, "RetVal", "clib.array.libm2k.Double", "nb_samples", "Description", "A pointer to the interleaved samples"); % '<MLTYPE>' can be clib.array.libm2k.Double, or double
validate(getSamplesInterleavedDefinition);

%% C++ class method |getSamplesRawInterleaved| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved(unsigned int nb_samples)
getSamplesRawInterleavedDefinition = addMethod(M2kAnalogInDefinition, ...
   "short const * libm2k::analog::M2kAnalogIn::getSamplesRawInterleaved(unsigned int nb_samples)", ...
   "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getSamplesRawInterleaved    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
   "Retrieve a specific number of raw samples from both channels", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getSamplesRawInterleavedDefinition, "nb_samples", "uint32", "Description", "nb_samples The number of samples that will be retrieved");
defineOutput(getSamplesRawInterleavedDefinition, "RetVal", "clib.array.libm2k.Short", "nb_samples", "Description", "A pointer to the interleaved raw samples"); % '<MLTYPE>' can be clib.array.libm2k.Short, or int16
validate(getSamplesRawInterleavedDefinition);

%% C++ class method |getVoltageRaw| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: short libm2k::analog::M2kAnalogIn::getVoltageRaw(unsigned int ch)
getVoltageRawDefinition = addMethod(M2kAnalogInDefinition, ...
    "short libm2k::analog::M2kAnalogIn::getVoltageRaw(unsigned int ch)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getVoltageRaw    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the average raw value of the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getVoltageRawDefinition, "ch", "uint32", "Description", "ch The index corresponding to the channel");
defineOutput(getVoltageRawDefinition, "RetVal", "int16", "Description", "The average raw value");
validate(getVoltageRawDefinition);

%% C++ class method |getVoltage| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::getVoltage(unsigned int ch)
getVoltageDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::getVoltage(unsigned int ch)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getVoltage    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the average voltage of the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getVoltageDefinition, "ch", "uint32", "Description", "ch The index corresponding to the channel");
defineOutput(getVoltageDefinition, "RetVal", "double", "Description", "The average voltage");
validate(getVoltageDefinition);

%% C++ class method |getVoltageRaw| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: short libm2k::analog::M2kAnalogIn::getVoltageRaw(libm2k::analog::ANALOG_IN_CHANNEL ch)
getVoltageRawDefinition = addMethod(M2kAnalogInDefinition, ...
    "short libm2k::analog::M2kAnalogIn::getVoltageRaw(libm2k::analog::ANALOG_IN_CHANNEL ch)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getVoltageRaw    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the average raw value of the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getVoltageRawDefinition, "ch", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "ch  An enumerator corresponding to the channel's index");
defineOutput(getVoltageRawDefinition, "RetVal", "int16", "Description", "The average raw value");
validate(getVoltageRawDefinition);

%% C++ class method |getVoltage| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::getVoltage(libm2k::analog::ANALOG_IN_CHANNEL ch)
getVoltageDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::getVoltage(libm2k::analog::ANALOG_IN_CHANNEL ch)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getVoltage    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the average voltage of the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getVoltageDefinition, "ch", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "ch An enumerator corresponding to the channel's index");
defineOutput(getVoltageDefinition, "RetVal", "double", "Description", "The average voltage");
validate(getVoltageDefinition);

%% C++ class method |getVoltageRaw| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: std::__1::vector<short, std::__1::allocator<short>> libm2k::analog::M2kAnalogIn::getVoltageRaw()
getVoltageRawDefinition = addMethod(M2kAnalogInDefinition, ...
    "std::__1::vector<short, std::__1::allocator<short>> libm2k::analog::M2kAnalogIn::getVoltageRaw()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getVoltageRaw    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the average raw value for each channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getVoltageRawDefinition, "RetVal", "clib.array.libm2k.Short", "Description", "A list containing the average raw value of each channel");
validate(getVoltageRawDefinition);

%% C++ class method |getVoltage| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogIn::getVoltage()
getVoltageDefinition = addMethod(M2kAnalogInDefinition, ...
    "std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogIn::getVoltage()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getVoltage    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the average voltage for each channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getVoltageDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "A list containing the average voltage of each channel");
validate(getVoltageDefinition);

%% C++ class method |getVoltageRawP| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: short const * libm2k::analog::M2kAnalogIn::getVoltageRawP()
%getVoltageRawPDefinition = addMethod(M2kAnalogInDefinition, ...
%    "short const * libm2k::analog::M2kAnalogIn::getVoltageRawP()", ...
%    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getVoltageRawP    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
%    "Retrieve the average raw value for both channels", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineOutput(getVoltageRawPDefinition, "RetVal", "clib.array.libm2k.Short", <SHAPE>, "Description", "A pointer to the average raw value of both channels"); % '<MLTYPE>' can be clib.array.libm2k.Short, or int16
%validate(getVoltageRawPDefinition);

%% C++ class method |getVoltageP| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double const * libm2k::analog::M2kAnalogIn::getVoltageP()
%getVoltagePDefinition = addMethod(M2kAnalogInDefinition, ...
%    "double const * libm2k::analog::M2kAnalogIn::getVoltageP()", ...
%    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getVoltageP    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
%    "Retrieve the average voltage for both channels", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineOutput(getVoltagePDefinition, "RetVal", "clib.array.libm2k.Double", <SHAPE>, "Description", "A pointer to the average voltage of both channels"); % '<MLTYPE>' can be clib.array.libm2k.Double, or double
%validate(getVoltagePDefinition);

%% C++ class method |setVerticalOffset| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: void libm2k::analog::M2kAnalogIn::setVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel,double vertOffset)
setVerticalOffsetDefinition = addMethod(M2kAnalogInDefinition, ...
    "void libm2k::analog::M2kAnalogIn::setVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel,double vertOffset)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.setVerticalOffset    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Set the vertical offset, in Volts, of a specific channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setVerticalOffsetDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel the index of the channel");
defineArgument(setVerticalOffsetDefinition, "vertOffset", "double", "Description", "vertOffset the value of the offset in Volts");
validate(setVerticalOffsetDefinition);

%% C++ class method |getVerticalOffset| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::getVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel)
getVerticalOffsetDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::getVerticalOffset(libm2k::analog::ANALOG_IN_CHANNEL channel)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getVerticalOffset    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "getVerticalOffset", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getVerticalOffsetDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel the index of the channel");
defineOutput(getVerticalOffsetDefinition, "RetVal", "double", "Description", "the value of the offset in Volts");
validate(getVerticalOffsetDefinition);

%% C++ class method |getScalingFactor| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::getScalingFactor(libm2k::analog::ANALOG_IN_CHANNEL ch)
getScalingFactorDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::getScalingFactor(libm2k::analog::ANALOG_IN_CHANNEL ch)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getScalingFactor    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the scaling factor", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getScalingFactorDefinition, "ch", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "ch An enumerator corresponding to the channel's index");
defineOutput(getScalingFactorDefinition, "RetVal", "double", "Description", "The value of the scaling factor");
validate(getScalingFactorDefinition);

%% C++ class method |setRange| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,libm2k::analog::M2K_RANGE range)
setRangeDefinition = addMethod(M2kAnalogInDefinition, ...
    "void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,libm2k::analog::M2K_RANGE range)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.setRange    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Set the range for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setRangeDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel An enumerator corresponding to the channel's index");
defineArgument(setRangeDefinition, "range", "clib.libm2k.libm2k.analog.M2K_RANGE", "Description", "range  An enumerator corresponding to a range");
validate(setRangeDefinition);

%% C++ class method |setRange| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,double min,double max)
setRangeDefinition = addMethod(M2kAnalogInDefinition, ...
    "void libm2k::analog::M2kAnalogIn::setRange(libm2k::analog::ANALOG_IN_CHANNEL channel,double min,double max)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.setRange    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Set the range for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setRangeDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel An enumerator corresponding to the channel's index");
defineArgument(setRangeDefinition, "min", "double", "Description", "min Upper bound");
defineArgument(setRangeDefinition, "max", "double", "Description", "max Lower bound");
validate(setRangeDefinition);

%% C++ class method |getRange| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: libm2k::analog::M2K_RANGE libm2k::analog::M2kAnalogIn::getRange(libm2k::analog::ANALOG_IN_CHANNEL channel)
getRangeDefinition = addMethod(M2kAnalogInDefinition, ...
    "libm2k::analog::M2K_RANGE libm2k::analog::M2kAnalogIn::getRange(libm2k::analog::ANALOG_IN_CHANNEL channel)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getRange    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the range for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getRangeDefinition, "channel", "clib.libm2k.libm2k.analog.ANALOG_IN_CHANNEL", "Description", "channel An enumerator corresponding to the channel's index");
defineOutput(getRangeDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2K_RANGE", "Description", "An enumerator corresponding to the range");
validate(getRangeDefinition);

%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: int libm2k::analog::M2kAnalogIn::getOversamplingRatio()
getOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ...
    "int libm2k::analog::M2kAnalogIn::getOversamplingRatio()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getOversamplingRatio    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the global oversampling ratio", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getOversamplingRatioDefinition, "RetVal", "int32", "Description", "The value of the global ratio");
validate(getOversamplingRatioDefinition);

%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: int libm2k::analog::M2kAnalogIn::getOversamplingRatio(unsigned int chn_idx)
getOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ...
    "int libm2k::analog::M2kAnalogIn::getOversamplingRatio(unsigned int chn_idx)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getOversamplingRatio    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the oversampling ratio for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getOversamplingRatioDefinition, "chn_idx", "uint32", "Description", "chn_idx The index corresponding to the channel");
defineOutput(getOversamplingRatioDefinition, "RetVal", "int32", "Description", "The ratio value");
validate(getOversamplingRatioDefinition);

%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: int libm2k::analog::M2kAnalogIn::setOversamplingRatio(int oversampling)
setOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ...
    "int libm2k::analog::M2kAnalogIn::setOversamplingRatio(int oversampling)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.setOversamplingRatio    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Set the global oversampling ratio", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setOversamplingRatioDefinition, "oversampling", "int32", "Description", "oversampling Integer value to set the oversampling ratio to");
defineOutput(setOversamplingRatioDefinition, "RetVal", "int32", "Description", "The current value of the global ratio");
validate(setOversamplingRatioDefinition);

%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: int libm2k::analog::M2kAnalogIn::setOversamplingRatio(unsigned int chn_idx,int oversampling)
setOversamplingRatioDefinition = addMethod(M2kAnalogInDefinition, ...
    "int libm2k::analog::M2kAnalogIn::setOversamplingRatio(unsigned int chn_idx,int oversampling)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.setOversamplingRatio    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Set the oversampling ratio for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setOversamplingRatioDefinition, "chn_idx", "uint32", "Description", "chn_idx The index corresponding to the channel");
defineArgument(setOversamplingRatioDefinition, "oversampling", "int32", "Description", "oversampling Integer value to set the oversampling ratio to");
defineOutput(setOversamplingRatioDefinition, "RetVal", "int32", "Description", "The current ratio value");
validate(setOversamplingRatioDefinition);

%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::getSampleRate()
getSampleRateDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::getSampleRate()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getSampleRate    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the global sample rate", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate");
validate(getSampleRateDefinition);

%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::getSampleRate(unsigned int chn_idx)
getSampleRateDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::getSampleRate(unsigned int chn_idx)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getSampleRate    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the sample rate of the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getSampleRateDefinition, "chn_idx", "uint32", "Description", "chn_idx The index corresponding to the channel");
defineOutput(getSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate");
validate(getSampleRateDefinition);

%% C++ class method |getAvailableSampleRates| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogIn::getAvailableSampleRates()
getAvailableSampleRatesDefinition = addMethod(M2kAnalogInDefinition, ...
    "std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogIn::getAvailableSampleRates()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getAvailableSampleRates    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "getAvailableSampleRates", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getAvailableSampleRatesDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "The list of available samplerates for this device");
validate(getAvailableSampleRatesDefinition);

%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::setSampleRate(double samplerate)
setSampleRateDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::setSampleRate(double samplerate)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.setSampleRate    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Set the global sample rate", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setSampleRateDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to");
defineOutput(setSampleRateDefinition, "RetVal", "double", "Description", "The value of the global sample rate");
validate(setSampleRateDefinition);

%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::setSampleRate(unsigned int chn_idx,double samplerate)
setSampleRateDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::setSampleRate(unsigned int chn_idx,double samplerate)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.setSampleRate    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Set the sample rate of the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setSampleRateDefinition, "chn_idx", "uint32", "Description", "chn_idx The index corresponding to the channel");
defineArgument(setSampleRateDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to");
defineOutput(setSampleRateDefinition, "RetVal", "double", "Description", "The value of the global sample rate");
validate(setSampleRateDefinition);

%% C++ class method |getFilterCompensation| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::getFilterCompensation(double samplerate)
getFilterCompensationDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::getFilterCompensation(double samplerate)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getFilterCompensation    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the filter compensation for the given sample rate", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getFilterCompensationDefinition, "samplerate", "double", "Description", "samplerate A double value representing the sample rate");
defineOutput(getFilterCompensationDefinition, "RetVal", "double", "Description", "The value of the filter compensation");
validate(getFilterCompensationDefinition);

%% C++ class method |getValueForRange| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::getValueForRange(libm2k::analog::M2K_RANGE range)
getValueForRangeDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::getValueForRange(libm2k::analog::M2K_RANGE range)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getValueForRange    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the numeric value corresponding to the given range", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getValueForRangeDefinition, "range", "clib.libm2k.libm2k.analog.M2K_RANGE", "Description", "range");
defineOutput(getValueForRangeDefinition, "RetVal", "double", "Description", "double");
validate(getValueForRangeDefinition);

%% C++ class method |convertRawToVolts| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::convertRawToVolts(unsigned int channel,short raw)
convertRawToVoltsDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::convertRawToVolts(unsigned int channel,short raw)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.convertRawToVolts    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Convert the raw value of a sample into volts", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(convertRawToVoltsDefinition, "channel", "uint32", "Description", "raw: the raw value of a sample;");
defineArgument(convertRawToVoltsDefinition, "raw", "int16", "Description", "channel: The index corresponding to the channel;");
defineOutput(convertRawToVoltsDefinition, "RetVal", "double", "Description", "The value of a sample converted into volts;");
validate(convertRawToVoltsDefinition);

%% C++ class method |convertVoltsToRaw| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: short libm2k::analog::M2kAnalogIn::convertVoltsToRaw(unsigned int channel,double voltage)
convertVoltsToRawDefinition = addMethod(M2kAnalogInDefinition, ...
    "short libm2k::analog::M2kAnalogIn::convertVoltsToRaw(unsigned int channel,double voltage)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.convertVoltsToRaw    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Convert the voltage value of a sample into raw", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(convertVoltsToRawDefinition, "channel", "uint32", "Description", "voltage The voltage value of a sample;");
defineArgument(convertVoltsToRawDefinition, "voltage", "double", "Description", "channel The index corresponding to the channel;");
defineOutput(convertVoltsToRawDefinition, "RetVal", "int16", "Description", "The value of a sample converted into raw;");
validate(convertVoltsToRawDefinition);

%% C++ class method |getNbChannels| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: unsigned int libm2k::analog::M2kAnalogIn::getNbChannels()
getNbChannelsDefinition = addMethod(M2kAnalogInDefinition, ...
    "unsigned int libm2k::analog::M2kAnalogIn::getNbChannels()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getNbChannels    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the number of analogical channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getNbChannelsDefinition, "RetVal", "uint32", "Description", "The number of channels");
validate(getNbChannelsDefinition);

%% C++ class method |getName| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: std::string libm2k::analog::M2kAnalogIn::getName()
getNameDefinition = addMethod(M2kAnalogInDefinition, ...
    "std::string libm2k::analog::M2kAnalogIn::getName()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getName    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the name of the device", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getNameDefinition, "RetVal", "string", "Description", "The name of the device");
validate(getNameDefinition);

%% C++ class method |enableChannel| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: void libm2k::analog::M2kAnalogIn::enableChannel(unsigned int chnIdx,bool enable)
enableChannelDefinition = addMethod(M2kAnalogInDefinition, ...
    "void libm2k::analog::M2kAnalogIn::enableChannel(unsigned int chnIdx,bool enable)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.enableChannel    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Enable or disable the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(enableChannelDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel");
defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state");
validate(enableChannelDefinition);

%% C++ class method |isChannelEnabled| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: bool libm2k::analog::M2kAnalogIn::isChannelEnabled(unsigned int chnIdx)
isChannelEnabledDefinition = addMethod(M2kAnalogInDefinition, ...
    "bool libm2k::analog::M2kAnalogIn::isChannelEnabled(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.isChannelEnabled    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Retrieve the state of the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(isChannelEnabledDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel");
defineOutput(isChannelEnabledDefinition, "RetVal", "logical", "Description", "True if the channel is enabled");
validate(isChannelEnabledDefinition);

%% C++ class method |cancelAcquisition| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: void libm2k::analog::M2kAnalogIn::cancelAcquisition()
cancelAcquisitionDefinition = addMethod(M2kAnalogInDefinition, ...
    "void libm2k::analog::M2kAnalogIn::cancelAcquisition()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.cancelAcquisition    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Cancel all buffer operations" + newline + ...
    "	@note Should be used to cancel an ongoing acquisition", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@brief Cancel all buffer operations" + newline + ...
    "	@note Should be used to cancel an ongoing acquisition"); % Modify help description values as needed.
validate(cancelAcquisitionDefinition);

%% C++ class method |setKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: void libm2k::analog::M2kAnalogIn::setKernelBuffersCount(unsigned int count)
setKernelBuffersCountDefinition = addMethod(M2kAnalogInDefinition, ...
    "void libm2k::analog::M2kAnalogIn::setKernelBuffersCount(unsigned int count)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.setKernelBuffersCount    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Set the kernel buffers to a specific value", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setKernelBuffersCountDefinition, "count", "uint32", "Description", "count the number of kernel buffers");
validate(setKernelBuffersCountDefinition);

%% C++ class method |getTrigger| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: libm2k::M2kHardwareTrigger * libm2k::analog::M2kAnalogIn::getTrigger()
getTriggerDefinition = addMethod(M2kAnalogInDefinition, ...
   "libm2k::M2kHardwareTrigger * libm2k::analog::M2kAnalogIn::getTrigger()", ...
   "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getTrigger    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
   "Get the hardware trigger handler", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getTriggerDefinition, "RetVal", "clib.libm2k.libm2k.M2kHardwareTrigger", 1, "Description", "A pointer to the hardware trigger trigger"); % '<MLTYPE>' can be clib.libm2k.libm2k.M2kHardwareTrigger, or clib.array.libm2k.libm2k.M2kHardwareTrigger
validate(getTriggerDefinition);

%% C++ class method |getIioObjects| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogIn::getIioObjects()
getIioObjectsDefinition = addMethod(M2kAnalogInDefinition, ...
    "libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogIn::getIioObjects()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getIioObjects    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Get access to IIO channels, buffers, devices and context." + newline + ...
    "	 Can be used when debugging directly with libiio.", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getIioObjectsDefinition, "RetVal", "clib.libm2k.libm2k.IIO_OBJECTS", "Description", "IIO_OBJECTS structure.");
validate(getIioObjectsDefinition);

%% C++ class method |getChannelName| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: std::string libm2k::analog::M2kAnalogIn::getChannelName(unsigned int channel)
getChannelNameDefinition = addMethod(M2kAnalogInDefinition, ...
    "std::string libm2k::analog::M2kAnalogIn::getChannelName(unsigned int channel)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getChannelName    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Get the channel name for each ADC channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getChannelNameDefinition, "channel", "uint32", "Description", "channel - unsigned int representing the index of the channel");
defineOutput(getChannelNameDefinition, "RetVal", "string", "Description", "std::string - name of the channel");
validate(getChannelNameDefinition);

%% C++ class method |getMaximumSamplerate| for C++ class |libm2k::analog::M2kAnalogIn|
% C++ Signature: double libm2k::analog::M2kAnalogIn::getMaximumSamplerate()
getMaximumSamplerateDefinition = addMethod(M2kAnalogInDefinition, ...
    "double libm2k::analog::M2kAnalogIn::getMaximumSamplerate()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogIn.getMaximumSamplerate    Method of C++ class libm2k::analog::M2kAnalogIn." + newline + ...
    "Get the maximum samplerate for the ADC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getMaximumSamplerateDefinition, "RetVal", "double", "Description", "double - the value of the maximum samplerate");
validate(getMaximumSamplerateDefinition);

%% C++ class |libm2k::analog::M2kAnalogOut| with MATLAB name |clib.libm2k.libm2k.analog.M2kAnalogOut|
M2kAnalogOutDefinition = addClass(libDef, "libm2k::analog::M2kAnalogOut", "MATLABName", "clib.libm2k.libm2k.analog.M2kAnalogOut", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut    Representation of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Contains the representation of the analogical output segment" + newline + ...
    "" + newline + ...
    "@class M2kAnalogOut" + newline + ...
    "@brief Controls the analogical output compound", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@defgroup analogout AnalogOut" + newline + ...
    "@brief Contains the representation of the analogical output segment" + newline + ...
    "" + newline + ...
    "@class M2kAnalogOut" + newline + ...
    "@brief Controls the analogical output compound"); % Modify help description values as needed.

%% C++ class method |reset| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::reset()
resetDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::reset()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.reset    Method of C++ class libm2k::analog::M2kAnalogOut.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(resetDefinition);

%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: std::__1::vector<int, std::__1::allocator<int>> libm2k::analog::M2kAnalogOut::getOversamplingRatio()
getOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ...
    "std::__1::vector<int, std::__1::allocator<int>> libm2k::analog::M2kAnalogOut::getOversamplingRatio()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getOversamplingRatio    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Retrieve the global oversampling ratio", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getOversamplingRatioDefinition, "RetVal", "clib.array.libm2k.Int", "Description", "The value of the global oversampling ratio");
validate(getOversamplingRatioDefinition);

%% C++ class method |getOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: int libm2k::analog::M2kAnalogOut::getOversamplingRatio(unsigned int chn)
getOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ...
    "int libm2k::analog::M2kAnalogOut::getOversamplingRatio(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getOversamplingRatio    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Retrieve the oversampling ratio for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getOversamplingRatioDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineOutput(getOversamplingRatioDefinition, "RetVal", "int32", "Description", "The oversampling ratio value");
validate(getOversamplingRatioDefinition);

%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: std::__1::vector<int, std::__1::allocator<int>> libm2k::analog::M2kAnalogOut::setOversamplingRatio(std::__1::vector<int, std::__1::allocator<int>> oversampling_ratio)
setOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ...
    "std::__1::vector<int, std::__1::allocator<int>> libm2k::analog::M2kAnalogOut::setOversamplingRatio(std::__1::vector<int, std::__1::allocator<int>> oversampling_ratio)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.setOversamplingRatio    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Set the value of the oversampling ratio for each channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setOversamplingRatioDefinition, "oversampling_ratio", "clib.array.libm2k.Int", "Description", "oversampling_ratio A list containing the ratios for each channel (as integers)");
defineOutput(setOversamplingRatioDefinition, "RetVal", "clib.array.libm2k.Int", "Description", "A list containing the oversampling ratio value for each channel");
validate(setOversamplingRatioDefinition);

%% C++ class method |setOversamplingRatio| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: int libm2k::analog::M2kAnalogOut::setOversamplingRatio(unsigned int chn,int oversampling_ratio)
setOversamplingRatioDefinition = addMethod(M2kAnalogOutDefinition, ...
    "int libm2k::analog::M2kAnalogOut::setOversamplingRatio(unsigned int chn,int oversampling_ratio)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.setOversamplingRatio    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Set the oversampling ratio for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setOversamplingRatioDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineArgument(setOversamplingRatioDefinition, "oversampling_ratio", "int32", "Description", "oversampling_ratio Integer value to set the oversampling ratio to");
defineOutput(setOversamplingRatioDefinition, "RetVal", "int32", "Description", "The current oversampling ratio value");
validate(setOversamplingRatioDefinition);

%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogOut::getSampleRate()
getSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ...
    "std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogOut::getSampleRate()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getSampleRate    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Retrieve the sample rate of both DACs", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getSampleRateDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "A list containing the sample rates");
validate(getSampleRateDefinition);

%% C++ class method |getSampleRate| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: double libm2k::analog::M2kAnalogOut::getSampleRate(unsigned int chn)
getSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ...
    "double libm2k::analog::M2kAnalogOut::getSampleRate(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getSampleRate    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Retrieve the sample rate for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getSampleRateDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineOutput(getSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate");
validate(getSampleRateDefinition);

%% C++ class method |getAvailableSampleRates| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogOut::getAvailableSampleRates(unsigned int chn)
getAvailableSampleRatesDefinition = addMethod(M2kAnalogOutDefinition, ...
    "std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogOut::getAvailableSampleRates(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getAvailableSampleRates    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "getAvailableSampleRates", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getAvailableSampleRatesDefinition, "chn", "uint32", "Description", "chn The index corresponding to the required channel");
defineOutput(getAvailableSampleRatesDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "The list of available samplerates for this device");
validate(getAvailableSampleRatesDefinition);

%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogOut::setSampleRate(std::__1::vector<double, std::__1::allocator<double>> samplerates)
setSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ...
    "std::__1::vector<double, std::__1::allocator<double>> libm2k::analog::M2kAnalogOut::setSampleRate(std::__1::vector<double, std::__1::allocator<double>> samplerates)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.setSampleRate    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Set the sample rate for both channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setSampleRateDefinition, "samplerates", "clib.array.libm2k.Double", "Description", "samplerates A list containing the sample rates of each channel");
defineOutput(setSampleRateDefinition, "RetVal", "clib.array.libm2k.Double", "Description", "A list containing the previously setted sample rates");
validate(setSampleRateDefinition);

%% C++ class method |setSampleRate| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: double libm2k::analog::M2kAnalogOut::setSampleRate(unsigned int chn,double samplerate)
setSampleRateDefinition = addMethod(M2kAnalogOutDefinition, ...
    "double libm2k::analog::M2kAnalogOut::setSampleRate(unsigned int chn,double samplerate)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.setSampleRate    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Set the sample rate for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setSampleRateDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineArgument(setSampleRateDefinition, "samplerate", "double", "Description", "samplerate A double value to set the sample rate to");
defineOutput(setSampleRateDefinition, "RetVal", "double", "Description", "The value of the sample rate");
validate(setSampleRateDefinition);

%% C++ class method |setSyncedDma| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::setSyncedDma(bool en,int chn)
setSyncedDmaDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::setSyncedDma(bool en,int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.setSyncedDma    Method of C++ class libm2k::analog::M2kAnalogOut.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineArgument(setSyncedDmaDefinition, "en", "logical");
defineArgument(setSyncedDmaDefinition, "chn", "int32");
validate(setSyncedDmaDefinition);

%% C++ class method |getSyncedDma| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: bool libm2k::analog::M2kAnalogOut::getSyncedDma(int chn)
getSyncedDmaDefinition = addMethod(M2kAnalogOutDefinition, ...
    "bool libm2k::analog::M2kAnalogOut::getSyncedDma(int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getSyncedDma    Method of C++ class libm2k::analog::M2kAnalogOut.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineArgument(getSyncedDmaDefinition, "chn", "int32");
defineOutput(getSyncedDmaDefinition, "RetVal", "logical");
validate(getSyncedDmaDefinition);

%% C++ class method |setSyncedStartDma| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::setSyncedStartDma(bool en,int chn)
setSyncedStartDmaDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::setSyncedStartDma(bool en,int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.setSyncedStartDma    Method of C++ class libm2k::analog::M2kAnalogOut.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineArgument(setSyncedStartDmaDefinition, "en", "logical");
defineArgument(setSyncedStartDmaDefinition, "chn", "int32");
validate(setSyncedStartDmaDefinition);

%% C++ class method |getSyncedStartDma| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: bool libm2k::analog::M2kAnalogOut::getSyncedStartDma(int chn)
getSyncedStartDmaDefinition = addMethod(M2kAnalogOutDefinition, ...
    "bool libm2k::analog::M2kAnalogOut::getSyncedStartDma(int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getSyncedStartDma    Method of C++ class libm2k::analog::M2kAnalogOut.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineArgument(getSyncedStartDmaDefinition, "chn", "int32");
defineOutput(getSyncedStartDmaDefinition, "RetVal", "logical");
validate(getSyncedStartDmaDefinition);

%% C++ class method |setCyclic| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::setCyclic(bool en)
setCyclicDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::setCyclic(bool en)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.setCyclic    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Enable or disable the cyclic mode for all digital channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setCyclicDefinition, "en", "logical", "Description", "en If true, enable cyclic mode");
validate(setCyclicDefinition);

%% C++ class method |setCyclic| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::setCyclic(unsigned int chn,bool en)
setCyclicDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::setCyclic(unsigned int chn,bool en)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.setCyclic    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Enable or disable the cyclic mode for all digital channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setCyclicDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineArgument(setCyclicDefinition, "en", "logical", "Description", "en If true, enable cyclic mode");
validate(setCyclicDefinition);

%% C++ class method |getCyclic| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: bool libm2k::analog::M2kAnalogOut::getCyclic(unsigned int chn)
getCyclicDefinition = addMethod(M2kAnalogOutDefinition, ...
    "bool libm2k::analog::M2kAnalogOut::getCyclic(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getCyclic    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Retrieve the value of the cyclic mode", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getCyclicDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineOutput(getCyclicDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the cyclic mode");
validate(getCyclicDefinition);

%% C++ class method |getScalingFactor| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: double libm2k::analog::M2kAnalogOut::getScalingFactor(unsigned int chn)
getScalingFactorDefinition = addMethod(M2kAnalogOutDefinition, ...
    "double libm2k::analog::M2kAnalogOut::getScalingFactor(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getScalingFactor    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Retrieve the scaling factor for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getScalingFactorDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineOutput(getScalingFactorDefinition, "RetVal", "double", "Description", "The value of the scaling factor");
validate(getScalingFactorDefinition);

%% C++ class method |getFilterCompensation| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: double libm2k::analog::M2kAnalogOut::getFilterCompensation(double samplerate)
getFilterCompensationDefinition = addMethod(M2kAnalogOutDefinition, ...
    "double libm2k::analog::M2kAnalogOut::getFilterCompensation(double samplerate)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getFilterCompensation    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Retrieve the filter compensation for the given sample rate", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getFilterCompensationDefinition, "samplerate", "double", "Description", "samplerate A double value representing the sample rate");
defineOutput(getFilterCompensationDefinition, "RetVal", "double", "Description", "The value of the filter compensation");
validate(getFilterCompensationDefinition);

%% C++ class method |pushBytes| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::pushBytes(unsigned int chnIdx,double * data,unsigned int nb_samples)
pushBytesDefinition = addMethod(M2kAnalogOutDefinition, ...
   "void libm2k::analog::M2kAnalogOut::pushBytes(unsigned int chnIdx,double * data,unsigned int nb_samples)", ...
   "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.pushBytes    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
   "Send the samples to the given channel", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(pushBytesDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel");
defineArgument(pushBytesDefinition, "data", "clib.array.libm2k.Double", "input", "nb_samples", "Description", "data A pointer to the samples"); % '<MLTYPE>' can be clib.array.libm2k.Double, or double
defineArgument(pushBytesDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples");
validate(pushBytesDefinition);

%% C++ class method |pushRawBytes| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::pushRawBytes(unsigned int chnIdx,short * data,unsigned int nb_samples)
pushRawBytesDefinition = addMethod(M2kAnalogOutDefinition, ...
   "void libm2k::analog::M2kAnalogOut::pushRawBytes(unsigned int chnIdx,short * data,unsigned int nb_samples)", ...
   "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.pushRawBytes    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
   "Send the samples to the given channel", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(pushRawBytesDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel");
defineArgument(pushRawBytesDefinition, "data", "clib.array.libm2k.Short", "input", "nb_samples", "Description", "data A pointer to the raw samples"); % '<MLTYPE>' can be clib.array.libm2k.Short, or int16
defineArgument(pushRawBytesDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples");
validate(pushRawBytesDefinition);

%% C++ class method |pushInterleaved| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::pushInterleaved(double * data,unsigned int nb_channels,unsigned int nb_samples)
pushInterleavedDefinition = addMethod(M2kAnalogOutDefinition, ...
   "void libm2k::analog::M2kAnalogOut::pushInterleaved(double * data,unsigned int nb_channels,unsigned int nb_samples)", ...
   "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.pushInterleaved    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
   "Send samples to all the channels", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(pushInterleavedDefinition, "data", "clib.array.libm2k.Double", "input", "nb_samples", "Description", "data A pointer to the interleaved data"); % '<MLTYPE>' can be clib.array.libm2k.Double, or double
defineArgument(pushInterleavedDefinition, "nb_channels", "uint32", "Description", "nb_channels the number of channels on which we want to push");
defineArgument(pushInterleavedDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples total (samples_per_channel channels)" + newline + ...
   "	@note Make sure the samples are interleaved" + newline + ...
   "	@note Streaming data is possible - required multiple kernel buffers" + newline + ...
   "	@note The given channel will be synchronized with the other channel");
validate(pushInterleavedDefinition);

%% C++ class method |pushRawInterleaved| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::pushRawInterleaved(short * data,unsigned int nb_channels,unsigned int nb_samples)
pushRawInterleavedDefinition = addMethod(M2kAnalogOutDefinition, ...
   "void libm2k::analog::M2kAnalogOut::pushRawInterleaved(short * data,unsigned int nb_channels,unsigned int nb_samples)", ...
   "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.pushRawInterleaved    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
   "Send samples to all the channels", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(pushRawInterleavedDefinition, "data", "clib.array.libm2k.Short", "input", "nb_samples", "Description", "data A pointer to the interleaved raw data"); % '<MLTYPE>' can be clib.array.libm2k.Short, or int16
defineArgument(pushRawInterleavedDefinition, "nb_channels", "uint32", "Description", "nb_channels the number of channels on which we want to push");
defineArgument(pushRawInterleavedDefinition, "nb_samples", "uint32", "Description", "nb_samples the number of samples total (samples_per_channel channels)" + newline + ...
   "	@note Make sure the raw samples are interleaved" + newline + ...
   "	@note Streaming data is possible - required multiple kernel buffers" + newline + ...
   "	@note The given channel will be synchronized with the other channel");
validate(pushRawInterleavedDefinition);

%% C++ class method |push| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::push(unsigned int chnIdx,std::__1::vector<double, std::__1::allocator<double>> const & data)
pushDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::push(unsigned int chnIdx,std::__1::vector<double, std::__1::allocator<double>> const & data)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.push    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Send the samples to the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(pushDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel");
defineArgument(pushDefinition, "data", "clib.array.libm2k.Double", "Description", "data A list of doubles containing all samples");
validate(pushDefinition);

%% C++ class method |pushRaw| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::pushRaw(unsigned int chnIdx,std::__1::vector<short, std::__1::allocator<short>> const & data)
pushRawDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::pushRaw(unsigned int chnIdx,std::__1::vector<short, std::__1::allocator<short>> const & data)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.pushRaw    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Send the samples to the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(pushRawDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel");
defineArgument(pushRawDefinition, "data", "clib.array.libm2k.Short", "Description", "data A list of shorts containing all samples");
validate(pushRawDefinition);

%% C++ class method |stop| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::stop()
stopDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::stop()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.stop    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Stop all channels from sending the signals.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@note Both DACs will be powered down"); % Modify help description values as needed.
validate(stopDefinition);

%% C++ class method |stop| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::stop(unsigned int chn)
stopDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::stop(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.stop    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Stop the given channels from sending the signals", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(stopDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
validate(stopDefinition);

%% C++ class method |cancelBuffer| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::cancelBuffer()
cancelBufferDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::cancelBuffer()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.cancelBuffer    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Cancel all buffer operations of enabled channels" + newline + ...
    "	 @note Should be used to cancel an ongoing data write.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@brief Cancel all buffer operations of enabled channels" + newline + ...
    "	 @note Should be used to cancel an ongoing data write."); % Modify help description values as needed.
validate(cancelBufferDefinition);

%% C++ class method |cancelBuffer| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::cancelBuffer(unsigned int chn)
cancelBufferDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::cancelBuffer(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.cancelBuffer    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Cancel all buffer operations of the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(cancelBufferDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel" + newline + ...
    "	 @note Should be used to cancel an ongoing data write.");
validate(cancelBufferDefinition);

%% C++ class method |enableChannel| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::enableChannel(unsigned int chnIdx,bool enable)
enableChannelDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::enableChannel(unsigned int chnIdx,bool enable)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.enableChannel    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Enable or disable the given digital channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(enableChannelDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel");
defineArgument(enableChannelDefinition, "enable", "logical", "Description", "enable A boolean value corresponding to the channel's state");
validate(enableChannelDefinition);

%% C++ class method |isChannelEnabled| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: bool libm2k::analog::M2kAnalogOut::isChannelEnabled(unsigned int chnIdx)
isChannelEnabledDefinition = addMethod(M2kAnalogOutDefinition, ...
    "bool libm2k::analog::M2kAnalogOut::isChannelEnabled(unsigned int chnIdx)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.isChannelEnabled    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Check if the given channel is enabled", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(isChannelEnabledDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel");
defineOutput(isChannelEnabledDefinition, "RetVal", "logical", "Description", "A boolean value corresponding to the state of the channel");
validate(isChannelEnabledDefinition);

%% C++ class method |setKernelBuffersCount| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: void libm2k::analog::M2kAnalogOut::setKernelBuffersCount(unsigned int chnIdx,unsigned int count)
setKernelBuffersCountDefinition = addMethod(M2kAnalogOutDefinition, ...
    "void libm2k::analog::M2kAnalogOut::setKernelBuffersCount(unsigned int chnIdx,unsigned int count)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.setKernelBuffersCount    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Set the kernel buffers to a specific value", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setKernelBuffersCountDefinition, "chnIdx", "uint32", "Description", "chnIdx The index corresponding to the channel");
defineArgument(setKernelBuffersCountDefinition, "count", "uint32", "Description", "count the number of kernel buffers");
validate(setKernelBuffersCountDefinition);

%% C++ class method |convertVoltsToRaw| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: short libm2k::analog::M2kAnalogOut::convertVoltsToRaw(unsigned int channel,double voltage)
convertVoltsToRawDefinition = addMethod(M2kAnalogOutDefinition, ...
    "short libm2k::analog::M2kAnalogOut::convertVoltsToRaw(unsigned int channel,double voltage)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.convertVoltsToRaw    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Convert the volts value of a sample into raw", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(convertVoltsToRawDefinition, "channel", "uint32", "Description", "channel The index corresponding to the channel");
defineArgument(convertVoltsToRawDefinition, "voltage", "double", "Description", "voltage The volts value of a sample");
defineOutput(convertVoltsToRawDefinition, "RetVal", "int16", "Description", "The value of a sample converted into raw");
validate(convertVoltsToRawDefinition);

%% C++ class method |convertRawToVolts| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: double libm2k::analog::M2kAnalogOut::convertRawToVolts(unsigned int channel,short raw)
convertRawToVoltsDefinition = addMethod(M2kAnalogOutDefinition, ...
    "double libm2k::analog::M2kAnalogOut::convertRawToVolts(unsigned int channel,short raw)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.convertRawToVolts    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Convert the raw value of a sample into volts", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(convertRawToVoltsDefinition, "channel", "uint32", "Description", "channel The index corresponding to the channel");
defineArgument(convertRawToVoltsDefinition, "raw", "int16", "Description", "raw The raw value of a sample");
defineOutput(convertRawToVoltsDefinition, "RetVal", "double", "Description", "The value of a sample converted into volts");
validate(convertRawToVoltsDefinition);

%% C++ class method |getIioObjects| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogOut::getIioObjects()
getIioObjectsDefinition = addMethod(M2kAnalogOutDefinition, ...
    "libm2k::IIO_OBJECTS libm2k::analog::M2kAnalogOut::getIioObjects()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getIioObjects    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Get access to IIO channels, buffers, devices and context." + newline + ...
    "	 @note Can be used when debugging directly with libiio.", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getIioObjectsDefinition, "RetVal", "clib.libm2k.libm2k.IIO_OBJECTS", "Description", "IIO_OBJECTS structure.");
validate(getIioObjectsDefinition);

%% C++ class method |getNbChannels| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: unsigned int libm2k::analog::M2kAnalogOut::getNbChannels()
getNbChannelsDefinition = addMethod(M2kAnalogOutDefinition, ...
    "unsigned int libm2k::analog::M2kAnalogOut::getNbChannels()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getNbChannels    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Retrieve the number of analogical channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getNbChannelsDefinition, "RetVal", "uint32", "Description", "The number of channels");
validate(getNbChannelsDefinition);

%% C++ class method |getChannelName| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: std::string libm2k::analog::M2kAnalogOut::getChannelName(unsigned int channel)
getChannelNameDefinition = addMethod(M2kAnalogOutDefinition, ...
    "std::string libm2k::analog::M2kAnalogOut::getChannelName(unsigned int channel)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getChannelName    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Get the channel name for each DAC channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getChannelNameDefinition, "channel", "uint32", "Description", "channel - unsigned int representing the index of the channel");
defineOutput(getChannelNameDefinition, "RetVal", "string", "Description", "std::string - name of the channel");
validate(getChannelNameDefinition);

%% C++ class method |getMaximumSamplerate| for C++ class |libm2k::analog::M2kAnalogOut|
% C++ Signature: double libm2k::analog::M2kAnalogOut::getMaximumSamplerate(unsigned int chn_idx)
getMaximumSamplerateDefinition = addMethod(M2kAnalogOutDefinition, ...
    "double libm2k::analog::M2kAnalogOut::getMaximumSamplerate(unsigned int chn_idx)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kAnalogOut.getMaximumSamplerate    Method of C++ class libm2k::analog::M2kAnalogOut." + newline + ...
    "Get the maximum samplerate for the DAC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getMaximumSamplerateDefinition, "chn_idx", "uint32", "Description", "chn_idx - unsigned int representing the index of the channel");
defineOutput(getMaximumSamplerateDefinition, "RetVal", "double", "Description", "double - the value of the maximum samplerate");
validate(getMaximumSamplerateDefinition);

%% C++ class |libm2k::analog::M2kPowerSupply| with MATLAB name |clib.libm2k.libm2k.analog.M2kPowerSupply|
M2kPowerSupplyDefinition = addClass(libDef, "libm2k::analog::M2kPowerSupply", "MATLABName", "clib.libm2k.libm2k.analog.M2kPowerSupply", ...
    "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply    Representation of C++ class libm2k::analog::M2kPowerSupply." + newline + ...
    "Contains the representation of the power supply" + newline + ...
    "" + newline + ...
    "@class M2kPowerSupply" + newline + ...
    "@brief Controls the power supply", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@defgroup powersupply PowerSupply" + newline + ...
    "@brief Contains the representation of the power supply" + newline + ...
    "" + newline + ...
    "@class M2kPowerSupply" + newline + ...
    "@brief Controls the power supply"); % Modify help description values as needed.

%% C++ class method |reset| for C++ class |libm2k::analog::M2kPowerSupply|
% C++ Signature: void libm2k::analog::M2kPowerSupply::reset()
resetDefinition = addMethod(M2kPowerSupplyDefinition, ...
    "void libm2k::analog::M2kPowerSupply::reset()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply.reset    Method of C++ class libm2k::analog::M2kPowerSupply.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(resetDefinition);

%% C++ class method |enableChannel| for C++ class |libm2k::analog::M2kPowerSupply|
% C++ Signature: void libm2k::analog::M2kPowerSupply::enableChannel(unsigned int chn,bool en)
enableChannelDefinition = addMethod(M2kPowerSupplyDefinition, ...
    "void libm2k::analog::M2kPowerSupply::enableChannel(unsigned int chn,bool en)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply.enableChannel    Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ...
    "Enable or disable the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(enableChannelDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineArgument(enableChannelDefinition, "en", "logical", "Description", "en A boolean value corresponding to the state of the channel");
validate(enableChannelDefinition);

%% C++ class method |enableAll| for C++ class |libm2k::analog::M2kPowerSupply|
% C++ Signature: void libm2k::analog::M2kPowerSupply::enableAll(bool en)
enableAllDefinition = addMethod(M2kPowerSupplyDefinition, ...
    "void libm2k::analog::M2kPowerSupply::enableAll(bool en)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply.enableAll    Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ...
    "Enable or disable all channels", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(enableAllDefinition, "en", "logical", "Description", "en A boolean value corresponding to the state of the channels");
validate(enableAllDefinition);

%% C++ class method |readChannel| for C++ class |libm2k::analog::M2kPowerSupply|
% C++ Signature: double libm2k::analog::M2kPowerSupply::readChannel(unsigned int chn)
readChannelDefinition = addMethod(M2kPowerSupplyDefinition, ...
    "double libm2k::analog::M2kPowerSupply::readChannel(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply.readChannel    Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ...
    "Retrieve the value of a given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(readChannelDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineOutput(readChannelDefinition, "RetVal", "double", "Description", "double The voltage transmitted by the given channel");
validate(readChannelDefinition);

%% C++ class method |pushChannel| for C++ class |libm2k::analog::M2kPowerSupply|
% C++ Signature: void libm2k::analog::M2kPowerSupply::pushChannel(unsigned int chn,double value)
pushChannelDefinition = addMethod(M2kPowerSupplyDefinition, ...
    "void libm2k::analog::M2kPowerSupply::pushChannel(unsigned int chn,double value)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply.pushChannel    Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ...
    "Set the voltage for the given channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(pushChannelDefinition, "chn", "uint32", "Description", "chn The index corresponding to the channel");
defineArgument(pushChannelDefinition, "value", "double", "Description", "value The voltage (up to 5V)");
validate(pushChannelDefinition);

%% C++ class method |powerDownDacs| for C++ class |libm2k::analog::M2kPowerSupply|
% C++ Signature: void libm2k::analog::M2kPowerSupply::powerDownDacs(bool powerdown)
powerDownDacsDefinition = addMethod(M2kPowerSupplyDefinition, ...
    "void libm2k::analog::M2kPowerSupply::powerDownDacs(bool powerdown)", ...
    "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply.powerDownDacs    Method of C++ class libm2k::analog::M2kPowerSupply.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineArgument(powerDownDacsDefinition, "powerdown", "logical");
validate(powerDownDacsDefinition);

%% C++ class method |anyChannelEnabled| for C++ class |libm2k::analog::M2kPowerSupply|
% C++ Signature: bool libm2k::analog::M2kPowerSupply::anyChannelEnabled()
anyChannelEnabledDefinition = addMethod(M2kPowerSupplyDefinition, ...
    "bool libm2k::analog::M2kPowerSupply::anyChannelEnabled()", ...
    "Description", "clib.libm2k.libm2k.analog.M2kPowerSupply.anyChannelEnabled    Method of C++ class libm2k::analog::M2kPowerSupply." + newline + ...
    "Check if there is at least one enabled channel", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(anyChannelEnabledDefinition, "RetVal", "logical", "Description", "On succes, true");
validate(anyChannelEnabledDefinition);

%% C++ class |libm2k::context::M2k| with MATLAB name |clib.libm2k.libm2k.context.M2k|
M2kDefinition = addClass(libDef, "libm2k::context::M2k", "MATLABName", "clib.libm2k.libm2k.context.M2k", ...
    "Description", "clib.libm2k.libm2k.context.M2k    Representation of C++ class libm2k::context::M2k." + newline + ...
    "Contains the representation of the M2K" + newline + ...
    "" + newline + ...
    "@class M2k" + newline + ...
    "@brief Controls the ADALM2000", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@defgroup m2k M2k" + newline + ...
    "@brief Contains the representation of the M2K" + newline + ...
    "" + newline + ...
    "@class M2k" + newline + ...
    "@brief Controls the ADALM2000"); % Modify help description values as needed.

%% C++ class method |reset| for C++ class |libm2k::context::M2k|
% C++ Signature: void libm2k::context::M2k::reset()
resetDefinition = addMethod(M2kDefinition, ...
    "void libm2k::context::M2k::reset()", ...
    "Description", "clib.libm2k.libm2k.context.M2k.reset    Method of C++ class libm2k::context::M2k." + newline + ...
    "Reset the M2K device to default settings:" + newline + ...
    "	 *	- Reset calibration coefficients" + newline + ...
    "	 *	- Maximum samplerates" + newline + ...
    "	 *	- Set oversampling ratio to 1" + newline + ...
    "	 *	- Set AnalogIn range to low range" + newline + ...
    "	 *	- Set kernel buffers count to 4 (analog/digital and in/out devices)" + newline + ...
    "	 *	- Disable all TX digital channels and enable all RX digital channels" + newline + ...
    "	 @note A calibration is needed afterwards", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@brief Reset the M2K device to default settings:" + newline + ...
    "	 *	- Reset calibration coefficients" + newline + ...
    "	 *	- Maximum samplerates" + newline + ...
    "	 *	- Set oversampling ratio to 1" + newline + ...
    "	 *	- Set AnalogIn range to low range" + newline + ...
    "	 *	- Set kernel buffers count to 4 (analog/digital and in/out devices)" + newline + ...
    "	 *	- Disable all TX digital channels and enable all RX digital channels" + newline + ...
    "	 @note A calibration is needed afterwards"); % Modify help description values as needed.
validate(resetDefinition);

%% C++ class method |deinitialize| for C++ class |libm2k::context::M2k|
% C++ Signature: void libm2k::context::M2k::deinitialize()
deinitializeDefinition = addMethod(M2kDefinition, ...
    "void libm2k::context::M2k::deinitialize()", ...
    "Description", "clib.libm2k.libm2k.context.M2k.deinitialize    Method of C++ class libm2k::context::M2k.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(deinitializeDefinition);

%% C++ class method |calibrate| for C++ class |libm2k::context::M2k|
% C++ Signature: bool libm2k::context::M2k::calibrate()
calibrateDefinition = addMethod(M2kDefinition, ...
    "bool libm2k::context::M2k::calibrate()", ...
    "Description", "clib.libm2k.libm2k.context.M2k.calibrate    Method of C++ class libm2k::context::M2k.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineOutput(calibrateDefinition, "RetVal", "logical");
validate(calibrateDefinition);

%% C++ class method |calibrateADC| for C++ class |libm2k::context::M2k|
% C++ Signature: bool libm2k::context::M2k::calibrateADC()
calibrateADCDefinition = addMethod(M2kDefinition, ...
    "bool libm2k::context::M2k::calibrateADC()", ...
    "Description", "clib.libm2k.libm2k.context.M2k.calibrateADC    Method of C++ class libm2k::context::M2k." + newline + ...
    "Calibrate the ADC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(calibrateADCDefinition, "RetVal", "logical", "Description", "On succces, true");
validate(calibrateADCDefinition);

%% C++ class method |calibrateDAC| for C++ class |libm2k::context::M2k|
% C++ Signature: bool libm2k::context::M2k::calibrateDAC()
calibrateDACDefinition = addMethod(M2kDefinition, ...
    "bool libm2k::context::M2k::calibrateDAC()", ...
    "Description", "clib.libm2k.libm2k.context.M2k.calibrateDAC    Method of C++ class libm2k::context::M2k." + newline + ...
    "Calibrate the DAC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(calibrateDACDefinition, "RetVal", "logical", "Description", "On succces, true");
validate(calibrateDACDefinition);

%% C++ class method |resetCalibration| for C++ class |libm2k::context::M2k|
% C++ Signature: bool libm2k::context::M2k::resetCalibration()
resetCalibrationDefinition = addMethod(M2kDefinition, ...
    "bool libm2k::context::M2k::resetCalibration()", ...
    "Description", "clib.libm2k.libm2k.context.M2k.resetCalibration    Method of C++ class libm2k::context::M2k.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
defineOutput(resetCalibrationDefinition, "RetVal", "logical");
validate(resetCalibrationDefinition);

%% C++ class method |getDigital| for C++ class |libm2k::context::M2k|
% C++ Signature: libm2k::digital::M2kDigital * libm2k::context::M2k::getDigital()
getDigitalDefinition = addMethod(M2kDefinition, ...
   "libm2k::digital::M2kDigital * libm2k::context::M2k::getDigital()", ...
   "Description", "clib.libm2k.libm2k.context.M2k.getDigital    Method of C++ class libm2k::context::M2k." + newline + ...
   "Retrieve the Digital object", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getDigitalDefinition, "RetVal", "clib.libm2k.libm2k.digital.M2kDigital", 1, "Description", "On success, a pointer to a Digital object" + newline + ...
   "	@throw EXC_INVALID_PARAMETER No M2K digital device found"); % '<MLTYPE>' can be clib.libm2k.libm2k.digital.M2kDigital, or clib.array.libm2k.libm2k.digital.M2kDigital
validate(getDigitalDefinition);

%% C++ class method |getPowerSupply| for C++ class |libm2k::context::M2k|
% C++ Signature: libm2k::analog::M2kPowerSupply * libm2k::context::M2k::getPowerSupply()
getPowerSupplyDefinition = addMethod(M2kDefinition, ...
   "libm2k::analog::M2kPowerSupply * libm2k::context::M2k::getPowerSupply()", ...
   "Description", "clib.libm2k.libm2k.context.M2k.getPowerSupply    Method of C++ class libm2k::context::M2k." + newline + ...
   "Retrieve the PowerSupply object", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getPowerSupplyDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kPowerSupply", 1, "Description", "On success, a pointer to a PowerSupply object" + newline + ...
   "	@throw EXC_INVALID_PARAMETER No M2K power supply"); % '<MLTYPE>' can be clib.libm2k.libm2k.analog.M2kPowerSupply, or clib.array.libm2k.libm2k.analog.M2kPowerSupply
validate(getPowerSupplyDefinition);

%% C++ class method |getAnalogIn| for C++ class |libm2k::context::M2k|
% C++ Signature: libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn()
getAnalogInDefinition = addMethod(M2kDefinition, ...
   "libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn()", ...
   "Description", "clib.libm2k.libm2k.context.M2k.getAnalogIn    Method of C++ class libm2k::context::M2k." + newline + ...
   "Retrieve the AnalogIn object", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getAnalogInDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kAnalogIn", 1, "Description", "On success, a pointer to an AnalogIn object"); % '<MLTYPE>' can be clib.libm2k.libm2k.analog.M2kAnalogIn, or clib.array.libm2k.libm2k.analog.M2kAnalogIn
validate(getAnalogInDefinition);

%% C++ class method |getAnalogIn| for C++ class |libm2k::context::M2k|
% C++ Signature: libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn(std::string dev_name)
%getAnalogInDefinition = addMethod(M2kDefinition, ...
%    "libm2k::analog::M2kAnalogIn * libm2k::context::M2k::getAnalogIn(std::string dev_name)", ...
%    "Description", "clib.libm2k.libm2k.context.M2k.getAnalogIn    Method of C++ class libm2k::context::M2k." + newline + ...
%    "Retrieve the AnalogIn object of a device", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(getAnalogInDefinition, "dev_name", "string", "Description", "dev_name The name corresponding to a device");
%defineOutput(getAnalogInDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kAnalogIn", <SHAPE>, "Description", "On success, a pointer to an AnalogIn object"); % '<MLTYPE>' can be clib.libm2k.libm2k.analog.M2kAnalogIn, or clib.array.libm2k.libm2k.analog.M2kAnalogIn
%validate(getAnalogInDefinition);

%% C++ class method |getAnalogOut| for C++ class |libm2k::context::M2k|
% C++ Signature: libm2k::analog::M2kAnalogOut * libm2k::context::M2k::getAnalogOut()
getAnalogOutDefinition = addMethod(M2kDefinition, ...
   "libm2k::analog::M2kAnalogOut * libm2k::context::M2k::getAnalogOut()", ...
   "Description", "clib.libm2k.libm2k.context.M2k.getAnalogOut    Method of C++ class libm2k::context::M2k." + newline + ...
   "Retrieve the AnalogOut object", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getAnalogOutDefinition, "RetVal", "clib.libm2k.libm2k.analog.M2kAnalogOut", 1, "Description", "On success, a pointer to an AnalogOut object"); % '<MLTYPE>' can be clib.libm2k.libm2k.analog.M2kAnalogOut, or clib.array.libm2k.libm2k.analog.M2kAnalogOut
validate(getAnalogOutDefinition);

%% C++ class method |getDacCalibrationOffset| for C++ class |libm2k::context::M2k|
% C++ Signature: int libm2k::context::M2k::getDacCalibrationOffset(unsigned int chn)
getDacCalibrationOffsetDefinition = addMethod(M2kDefinition, ...
    "int libm2k::context::M2k::getDacCalibrationOffset(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.context.M2k.getDacCalibrationOffset    Method of C++ class libm2k::context::M2k." + newline + ...
    "Get the calibration offset of the DAC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getDacCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel");
defineOutput(getDacCalibrationOffsetDefinition, "RetVal", "int32", "Description", "The value of the calibration offset");
validate(getDacCalibrationOffsetDefinition);

%% C++ class method |getDacCalibrationGain| for C++ class |libm2k::context::M2k|
% C++ Signature: double libm2k::context::M2k::getDacCalibrationGain(unsigned int chn)
getDacCalibrationGainDefinition = addMethod(M2kDefinition, ...
    "double libm2k::context::M2k::getDacCalibrationGain(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.context.M2k.getDacCalibrationGain    Method of C++ class libm2k::context::M2k." + newline + ...
    "Get the calibration gain of the DAC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getDacCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel");
defineOutput(getDacCalibrationGainDefinition, "RetVal", "double", "Description", "The value of the calibration gain");
validate(getDacCalibrationGainDefinition);

%% C++ class method |getAdcCalibrationOffset| for C++ class |libm2k::context::M2k|
% C++ Signature: int libm2k::context::M2k::getAdcCalibrationOffset(unsigned int chn)
getAdcCalibrationOffsetDefinition = addMethod(M2kDefinition, ...
    "int libm2k::context::M2k::getAdcCalibrationOffset(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.context.M2k.getAdcCalibrationOffset    Method of C++ class libm2k::context::M2k." + newline + ...
    "Get the calibration offset of the ADC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getAdcCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel");
defineOutput(getAdcCalibrationOffsetDefinition, "RetVal", "int32", "Description", "The value of the calibration offset");
validate(getAdcCalibrationOffsetDefinition);

%% C++ class method |getAdcCalibrationGain| for C++ class |libm2k::context::M2k|
% C++ Signature: double libm2k::context::M2k::getAdcCalibrationGain(unsigned int chn)
getAdcCalibrationGainDefinition = addMethod(M2kDefinition, ...
    "double libm2k::context::M2k::getAdcCalibrationGain(unsigned int chn)", ...
    "Description", "clib.libm2k.libm2k.context.M2k.getAdcCalibrationGain    Method of C++ class libm2k::context::M2k." + newline + ...
    "Get the calibration gain of the ADC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getAdcCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel");
defineOutput(getAdcCalibrationGainDefinition, "RetVal", "double", "Description", "The value of the calibration gain");
validate(getAdcCalibrationGainDefinition);

%% C++ class method |setDacCalibrationOffset| for C++ class |libm2k::context::M2k|
% C++ Signature: void libm2k::context::M2k::setDacCalibrationOffset(unsigned int chn,int offset)
setDacCalibrationOffsetDefinition = addMethod(M2kDefinition, ...
    "void libm2k::context::M2k::setDacCalibrationOffset(unsigned int chn,int offset)", ...
    "Description", "clib.libm2k.libm2k.context.M2k.setDacCalibrationOffset    Method of C++ class libm2k::context::M2k." + newline + ...
    "Set the calibration offset of the DAC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDacCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel");
defineArgument(setDacCalibrationOffsetDefinition, "offset", "int32", "Description", "offset The calibration offset value" + newline + ...
    "	@note Overrides the calibration coefficients.\n" + newline + ...
    "	Can be reset by running a calibration.");
validate(setDacCalibrationOffsetDefinition);

%% C++ class method |setDacCalibrationGain| for C++ class |libm2k::context::M2k|
% C++ Signature: void libm2k::context::M2k::setDacCalibrationGain(unsigned int chn,double gain)
setDacCalibrationGainDefinition = addMethod(M2kDefinition, ...
    "void libm2k::context::M2k::setDacCalibrationGain(unsigned int chn,double gain)", ...
    "Description", "clib.libm2k.libm2k.context.M2k.setDacCalibrationGain    Method of C++ class libm2k::context::M2k." + newline + ...
    "Set the calibration gain of the DAC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setDacCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel");
defineArgument(setDacCalibrationGainDefinition, "gain", "double", "Description", "gain The calibration gain value" + newline + ...
    "	@note Overrides the calibration coefficients.\n" + newline + ...
    "	Can be reset by running a calibration.\n" + newline + ...
    "	The gain value is currently limited at the (-2,2) range  by the hardware.");
validate(setDacCalibrationGainDefinition);

%% C++ class method |setAdcCalibrationOffset| for C++ class |libm2k::context::M2k|
% C++ Signature: void libm2k::context::M2k::setAdcCalibrationOffset(unsigned int chn,int offset)
setAdcCalibrationOffsetDefinition = addMethod(M2kDefinition, ...
    "void libm2k::context::M2k::setAdcCalibrationOffset(unsigned int chn,int offset)", ...
    "Description", "clib.libm2k.libm2k.context.M2k.setAdcCalibrationOffset    Method of C++ class libm2k::context::M2k." + newline + ...
    "Set the calibration offset of the ADC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAdcCalibrationOffsetDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel");
defineArgument(setAdcCalibrationOffsetDefinition, "offset", "int32", "Description", "offset The calibration offset value" + newline + ...
    "	@note Overrides the calibration coefficients.\n" + newline + ...
    "	Can be reset by running a calibration.");
validate(setAdcCalibrationOffsetDefinition);

%% C++ class method |setAdcCalibrationGain| for C++ class |libm2k::context::M2k|
% C++ Signature: void libm2k::context::M2k::setAdcCalibrationGain(unsigned int chn,double gain)
setAdcCalibrationGainDefinition = addMethod(M2kDefinition, ...
    "void libm2k::context::M2k::setAdcCalibrationGain(unsigned int chn,double gain)", ...
    "Description", "clib.libm2k.libm2k.context.M2k.setAdcCalibrationGain    Method of C++ class libm2k::context::M2k." + newline + ...
    "Set the calibration gain of the ADC", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setAdcCalibrationGainDefinition, "chn", "uint32", "Description", "chn The index corresponding to a channel");
defineArgument(setAdcCalibrationGainDefinition, "gain", "double", "Description", "gain The calibration gain value" + newline + ...
    "	@note Overrides the calibration coefficients.\n" + newline + ...
    "	Can be reset by running a calibration.\n" + newline + ...
    "	The gain value is currently limited at the (-2,2) range  by the hardware.");
validate(setAdcCalibrationGainDefinition);

%% C++ class method |setLed| for C++ class |libm2k::context::M2k|
% C++ Signature: void libm2k::context::M2k::setLed(bool on)
setLedDefinition = addMethod(M2kDefinition, ...
    "void libm2k::context::M2k::setLed(bool on)", ...
    "Description", "clib.libm2k.libm2k.context.M2k.setLed    Method of C++ class libm2k::context::M2k." + newline + ...
    "Turn on or off the board's led", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setLedDefinition, "on", "logical", "Description", "on A boolean value corresponding to the state of the led");
validate(setLedDefinition);

%% C++ class method |getLed| for C++ class |libm2k::context::M2k|
% C++ Signature: bool libm2k::context::M2k::getLed()
getLedDefinition = addMethod(M2kDefinition, ...
    "bool libm2k::context::M2k::getLed()", ...
    "Description", "clib.libm2k.libm2k.context.M2k.getLed    Method of C++ class libm2k::context::M2k." + newline + ...
    "Retrieve the state of the led", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getLedDefinition, "RetVal", "logical", "Description", "If the led is turned on, true");
validate(getLedDefinition);

%% C++ class |libm2k::context::Lidar| with MATLAB name |clib.libm2k.libm2k.context.Lidar|
LidarDefinition = addClass(libDef, "libm2k::context::Lidar", "MATLABName", "clib.libm2k.libm2k.context.Lidar", ...
    "Description", "clib.libm2k.libm2k.context.Lidar    Representation of C++ class libm2k::context::Lidar."); % Modify help description values as needed.

%% C++ class |libm2k::context::Generic| with MATLAB name |clib.libm2k.libm2k.context.Generic|
GenericDefinition = addClass(libDef, "libm2k::context::Generic", "MATLABName", "clib.libm2k.libm2k.context.Generic", ...
    "Description", "clib.libm2k.libm2k.context.Generic    Representation of C++ class libm2k::context::Generic."); % Modify help description values as needed.

%% C++ class |libm2k::context::Context| with MATLAB name |clib.libm2k.libm2k.context.Context|
ContextDefinition = addClass(libDef, "libm2k::context::Context", "MATLABName", "clib.libm2k.libm2k.context.Context", ...
    "Description", "clib.libm2k.libm2k.context.Context    Representation of C++ class libm2k::context::Context." + newline + ...
    "Contains the representation of a generic IIO context" + newline + ...
    "" + newline + ...
    "@class Context" + newline + ...
    "@brief Controls the IIO context"); % Modify help description values as needed.

%% C++ class method |reset| for C++ class |libm2k::context::Context|
% C++ Signature: void libm2k::context::Context::reset()
resetDefinition = addMethod(ContextDefinition, ...
    "void libm2k::context::Context::reset()", ...
    "Description", "clib.libm2k.libm2k.context.Context.reset    Method of C++ class libm2k::context::Context.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(resetDefinition);

%% C++ class method |deinitialize| for C++ class |libm2k::context::Context|
% C++ Signature: void libm2k::context::Context::deinitialize()
deinitializeDefinition = addMethod(ContextDefinition, ...
    "void libm2k::context::Context::deinitialize()", ...
    "Description", "clib.libm2k.libm2k.context.Context.deinitialize    Method of C++ class libm2k::context::Context.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(deinitializeDefinition);

%% C++ class method |getUri| for C++ class |libm2k::context::Context|
% C++ Signature: std::string libm2k::context::Context::getUri()
getUriDefinition = addMethod(ContextDefinition, ...
    "std::string libm2k::context::Context::getUri()", ...
    "Description", "clib.libm2k.libm2k.context.Context.getUri    Method of C++ class libm2k::context::Context." + newline + ...
    "Get the URI of the current context", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getUriDefinition, "RetVal", "string", "Description", "string containt the context URI (ex: ""usb:1.2.3"", ""ip:192.168.2.1"")");
validate(getUriDefinition);

%% C++ class method |getDMM| for C++ class |libm2k::context::Context|
% C++ Signature: libm2k::analog::DMM * libm2k::context::Context::getDMM(unsigned int index)
%getDMMDefinition = addMethod(ContextDefinition, ...
%    "libm2k::analog::DMM * libm2k::context::Context::getDMM(unsigned int index)", ...
%    "Description", "clib.libm2k.libm2k.context.Context.getDMM    Method of C++ class libm2k::context::Context." + newline + ...
%    "Retrieve the DMM object at a certain index", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(getDMMDefinition, "index", "uint32", "Description", "index The index corresponding to the DMM");
%defineOutput(getDMMDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM", <SHAPE>, "Description", "On success, a pointer to a DMM object"); % '<MLTYPE>' can be clib.libm2k.libm2k.analog.DMM, or clib.array.libm2k.libm2k.analog.DMM
%validate(getDMMDefinition);

%% C++ class method |getDMM| for C++ class |libm2k::context::Context|
% C++ Signature: libm2k::analog::DMM * libm2k::context::Context::getDMM(std::string name)
%getDMMDefinition = addMethod(ContextDefinition, ...
%    "libm2k::analog::DMM * libm2k::context::Context::getDMM(std::string name)", ...
%    "Description", "clib.libm2k.libm2k.context.Context.getDMM    Method of C++ class libm2k::context::Context." + newline + ...
%    "Retrieve the DMM object which has the provided name", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(getDMMDefinition, "name", "string", "Description", "name The name corresponding to the DMM");
%defineOutput(getDMMDefinition, "RetVal", "clib.libm2k.libm2k.analog.DMM", <SHAPE>, "Description", "On success, a pointer to a DMM object"); % '<MLTYPE>' can be clib.libm2k.libm2k.analog.DMM, or clib.array.libm2k.libm2k.analog.DMM
%validate(getDMMDefinition);

%% C++ class method |getContextAttributeValue| for C++ class |libm2k::context::Context|
% C++ Signature: std::string libm2k::context::Context::getContextAttributeValue(std::string attr)
getContextAttributeValueDefinition = addMethod(ContextDefinition, ...
    "std::string libm2k::context::Context::getContextAttributeValue(std::string attr)", ...
    "Description", "clib.libm2k.libm2k.context.Context.getContextAttributeValue    Method of C++ class libm2k::context::Context." + newline + ...
    "Retrieve the value of one context attribute", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(getContextAttributeValueDefinition, "attr", "string", "Description", "attr The name of the required attribute");
defineOutput(getContextAttributeValueDefinition, "RetVal", "string", "Description", "On success, return a string containing the value of the attribute" + newline + ...
    "	 @throw On error, throw an exception if the attribute is not found");
validate(getContextAttributeValueDefinition);

%% C++ class method |getContextDescription| for C++ class |libm2k::context::Context|
% C++ Signature: std::string libm2k::context::Context::getContextDescription()
getContextDescriptionDefinition = addMethod(ContextDefinition, ...
    "std::string libm2k::context::Context::getContextDescription()", ...
    "Description", "clib.libm2k.libm2k.context.Context.getContextDescription    Method of C++ class libm2k::context::Context." + newline + ...
    "Retrieve a detailed context description", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getContextDescriptionDefinition, "RetVal", "string", "Description", "string containing the current context description");
validate(getContextDescriptionDefinition);

%% C++ class method |getSerialNumber| for C++ class |libm2k::context::Context|
% C++ Signature: std::string libm2k::context::Context::getSerialNumber()
getSerialNumberDefinition = addMethod(ContextDefinition, ...
    "std::string libm2k::context::Context::getSerialNumber()", ...
    "Description", "clib.libm2k.libm2k.context.Context.getSerialNumber    Method of C++ class libm2k::context::Context." + newline + ...
    "Retrieve the current context serial number", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getSerialNumberDefinition, "RetVal", "string", "Description", "string containing the current context serial number");
validate(getSerialNumberDefinition);

%% C++ class method |toM2k| for C++ class |libm2k::context::Context|
% C++ Signature: libm2k::context::M2k * libm2k::context::Context::toM2k()
%toM2kDefinition = addMethod(ContextDefinition, ...
%    "libm2k::context::M2k * libm2k::context::Context::toM2k()", ...
%    "Description", "clib.libm2k.libm2k.context.Context.toM2k    Method of C++ class libm2k::context::Context." + newline + ...
%    "Convert the current context to M2k context, if possible", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineOutput(toM2kDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", <SHAPE>, "Description", "On success, return the corresponding M2k object"); % '<MLTYPE>' can be clib.libm2k.libm2k.context.M2k, or clib.array.libm2k.libm2k.context.M2k
%validate(toM2kDefinition);

%% C++ class method |toLidar| for C++ class |libm2k::context::Context|
% C++ Signature: libm2k::context::Lidar * libm2k::context::Context::toLidar()
%toLidarDefinition = addMethod(ContextDefinition, ...
%    "libm2k::context::Lidar * libm2k::context::Context::toLidar()", ...
%    "Description", "clib.libm2k.libm2k.context.Context.toLidar    Method of C++ class libm2k::context::Context." + newline + ...
%    "Convert the current context to Lidar context, if possible", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineOutput(toLidarDefinition, "RetVal", "clib.libm2k.libm2k.context.Lidar", <SHAPE>, "Description", "On success, return the corresponding Lidar object");
%validate(toLidarDefinition);

%% C++ class method |toGeneric| for C++ class |libm2k::context::Context|
% C++ Signature: libm2k::context::Generic * libm2k::context::Context::toGeneric()
%toGenericDefinition = addMethod(ContextDefinition, ...
%    "libm2k::context::Generic * libm2k::context::Context::toGeneric()", ...
%    "Description", "clib.libm2k.libm2k.context.Context.toGeneric    Method of C++ class libm2k::context::Context." + newline + ...
%    "Convert the current context to Generic context, if possible", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineOutput(toGenericDefinition, "RetVal", "clib.libm2k.libm2k.context.Generic", <SHAPE>, "Description", "On success, return the corresponding Generic object");
%validate(toGenericDefinition);

%% C++ class method |getDmmCount| for C++ class |libm2k::context::Context|
% C++ Signature: unsigned int libm2k::context::Context::getDmmCount()
getDmmCountDefinition = addMethod(ContextDefinition, ...
    "unsigned int libm2k::context::Context::getDmmCount()", ...
    "Description", "clib.libm2k.libm2k.context.Context.getDmmCount    Method of C++ class libm2k::context::Context." + newline + ...
    "Retrieve the number of DMM objects", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getDmmCountDefinition, "RetVal", "uint32", "Description", "an unsigned int representing the number of DMM objects in the context");
validate(getDmmCountDefinition);

%% C++ class method |getFirmwareVersion| for C++ class |libm2k::context::Context|
% C++ Signature: std::string libm2k::context::Context::getFirmwareVersion()
getFirmwareVersionDefinition = addMethod(ContextDefinition, ...
    "std::string libm2k::context::Context::getFirmwareVersion()", ...
    "Description", "clib.libm2k.libm2k.context.Context.getFirmwareVersion    Method of C++ class libm2k::context::Context." + newline + ...
    "Retrieve the firmware version of the current context", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getFirmwareVersionDefinition, "RetVal", "string", "Description", "a string containing the firmware version");
validate(getFirmwareVersionDefinition);

%% C++ class method |setTimeout| for C++ class |libm2k::context::Context|
% C++ Signature: void libm2k::context::Context::setTimeout(unsigned int timeout)
setTimeoutDefinition = addMethod(ContextDefinition, ...
    "void libm2k::context::Context::setTimeout(unsigned int timeout)", ...
    "Description", "clib.libm2k.libm2k.context.Context.setTimeout    Method of C++ class libm2k::context::Context." + newline + ...
    "Set a timeout for I/O operations", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineArgument(setTimeoutDefinition, "timeout", "uint32", "Description", "timeout A positive integer representing the time in milliseconds after which a timeout occurs. A value of 0 is used to specify that no timeout should occur.");
validate(setTimeoutDefinition);

%% C++ class |libm2k::context::ContextBuilder| with MATLAB name |clib.libm2k.libm2k.context.ContextBuilder|
ContextBuilderDefinition = addClass(libDef, "libm2k::context::ContextBuilder", "MATLABName", "clib.libm2k.libm2k.context.ContextBuilder", ...
    "Description", "clib.libm2k.libm2k.context.ContextBuilder    Representation of C++ class libm2k::context::ContextBuilder.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.

%% C++ class constructor for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: libm2k::context::ContextBuilder::ContextBuilder()
ContextBuilderConstructor1Definition = addConstructor(ContextBuilderDefinition, ...
    "libm2k::context::ContextBuilder::ContextBuilder()", ...
    "Description", "clib.libm2k.libm2k.context.ContextBuilder.ContextBuilder    Constructor of C++ class libm2k::context::ContextBuilder.", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@private"); % Modify help description values as needed.
validate(ContextBuilderConstructor1Definition);

%% C++ class method |contextOpen| for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(char const * input1)
%contextOpenDefinition = addMethod(ContextBuilderDefinition, ...
%    "static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(char const * input1)", ...
%    "Description", "clib.libm2k.libm2k.context.ContextBuilder.contextOpen    Method of C++ class libm2k::context::ContextBuilder.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineArgument(contextOpenDefinition, "input1", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.Context, or clib.array.libm2k.libm2k.context.Context
%validate(contextOpenDefinition);

%% C++ class method |contextOpen| for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(iio_context * input1,char const * input2)
%contextOpenDefinition = addMethod(ContextBuilderDefinition, ...
%    "static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen(iio_context * input1,char const * input2)", ...
%    "Description", "clib.libm2k.libm2k.context.ContextBuilder.contextOpen    Method of C++ class libm2k::context::ContextBuilder.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineArgument(contextOpenDefinition, "input1", "clib.libm2k.iio_context", "input", <SHAPE>);
%defineArgument(contextOpenDefinition, "input2", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.Context, or clib.array.libm2k.libm2k.context.Context
%validate(contextOpenDefinition);

%% C++ class method |contextOpen| for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen()
%contextOpenDefinition = addMethod(ContextBuilderDefinition, ...
%    "static libm2k::context::Context * libm2k::context::ContextBuilder::contextOpen()", ...
%    "Description", "clib.libm2k.libm2k.context.ContextBuilder.contextOpen    Method of C++ class libm2k::context::ContextBuilder.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.Context, or clib.array.libm2k.libm2k.context.Context
%validate(contextOpenDefinition);

%% C++ class method |m2kOpen| for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(char const * input1)
%m2kOpenDefinition = addMethod(ContextBuilderDefinition, ...
%    "static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(char const * input1)", ...
%    "Description", "clib.libm2k.libm2k.context.ContextBuilder.m2kOpen    Method of C++ class libm2k::context::ContextBuilder.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineArgument(m2kOpenDefinition, "input1", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.M2k, or clib.array.libm2k.libm2k.context.M2k
%validate(m2kOpenDefinition);

%% C++ class method |m2kOpen| for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(iio_context * input1,char const * input2)
%m2kOpenDefinition = addMethod(ContextBuilderDefinition, ...
%    "static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen(iio_context * input1,char const * input2)", ...
%    "Description", "clib.libm2k.libm2k.context.ContextBuilder.m2kOpen    Method of C++ class libm2k::context::ContextBuilder.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineArgument(m2kOpenDefinition, "input1", "clib.libm2k.iio_context", "input", <SHAPE>);
%defineArgument(m2kOpenDefinition, "input2", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.M2k, or clib.array.libm2k.libm2k.context.M2k
%validate(m2kOpenDefinition);

%% C++ class method |m2kOpen| for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen()
%m2kOpenDefinition = addMethod(ContextBuilderDefinition, ...
%    "static libm2k::context::M2k * libm2k::context::ContextBuilder::m2kOpen()", ...
%    "Description", "clib.libm2k.libm2k.context.ContextBuilder.m2kOpen    Method of C++ class libm2k::context::ContextBuilder.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.M2k, or clib.array.libm2k.libm2k.context.M2k
%validate(m2kOpenDefinition);

%% C++ class method |contextClose| for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: static void libm2k::context::ContextBuilder::contextClose(libm2k::context::Context * input1,bool deinit)
%contextCloseDefinition = addMethod(ContextBuilderDefinition, ...
%    "static void libm2k::context::ContextBuilder::contextClose(libm2k::context::Context * input1,bool deinit)", ...
%    "Description", "clib.libm2k.libm2k.context.ContextBuilder.contextClose    Method of C++ class libm2k::context::ContextBuilder.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineArgument(contextCloseDefinition, "input1", "clib.libm2k.libm2k.context.Context", "input", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.Context, or clib.array.libm2k.libm2k.context.Context
%defineArgument(contextCloseDefinition, "deinit", "logical");
%validate(contextCloseDefinition);

%% C++ class method |contextCloseAll| for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: static void libm2k::context::ContextBuilder::contextCloseAll()
contextCloseAllDefinition = addMethod(ContextBuilderDefinition, ...
    "static void libm2k::context::ContextBuilder::contextCloseAll()", ...
    "Description", "clib.libm2k.libm2k.context.ContextBuilder.contextCloseAll    Method of C++ class libm2k::context::ContextBuilder."); % Modify help description values as needed.
validate(contextCloseAllDefinition);

%% C++ class method |getVersion| for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: static std::string libm2k::context::ContextBuilder::getVersion()
getVersionDefinition = addMethod(ContextBuilderDefinition, ...
    "static std::string libm2k::context::ContextBuilder::getVersion()", ...
    "Description", "clib.libm2k.libm2k.context.ContextBuilder.getVersion    Method of C++ class libm2k::context::ContextBuilder."); % Modify help description values as needed.
defineOutput(getVersionDefinition, "RetVal", "string");
validate(getVersionDefinition);

%% C++ class constructor for C++ class |libm2k::context::ContextBuilder|
% C++ Signature: libm2k::context::ContextBuilder::ContextBuilder(libm2k::context::ContextBuilder const & input1)
ContextBuilderConstructor2Definition = addConstructor(ContextBuilderDefinition, ...
    "libm2k::context::ContextBuilder::ContextBuilder(libm2k::context::ContextBuilder const & input1)", ...
    "Description", "clib.libm2k.libm2k.context.ContextBuilder.ContextBuilder    Constructor of C++ class libm2k::context::ContextBuilder."); % Modify help description values as needed.
defineArgument(ContextBuilderConstructor2Definition, "input1", "clib.libm2k.libm2k.context.ContextBuilder", "input");
validate(ContextBuilderConstructor2Definition);

%% C++ function |libm2k::context::contextOpen| with MATLAB name |clib.libm2k.libm2k.context.contextOpen|
% C++ Signature: libm2k::context::Context * libm2k::context::contextOpen()
%contextOpenDefinition = addFunction(libDef, ...
%    "libm2k::context::Context * libm2k::context::contextOpen()", ...
%    "MATLABName", "clib.libm2k.libm2k.context.contextOpen", ...
%    "Description", "clib.libm2k.libm2k.context.contextOpen    Representation of C++ function libm2k::context::contextOpen.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.Context, or clib.array.libm2k.libm2k.context.Context
%validate(contextOpenDefinition);

%% C++ function |libm2k::context::contextOpen| with MATLAB name |clib.libm2k.libm2k.context.contextOpen|
% C++ Signature: libm2k::context::Context * libm2k::context::contextOpen(char const * uri)
%contextOpenDefinition = addFunction(libDef, ...
%    "libm2k::context::Context * libm2k::context::contextOpen(char const * uri)", ...
%    "MATLABName", "clib.libm2k.libm2k.context.contextOpen", ...
%    "Description", "clib.libm2k.libm2k.context.contextOpen    Representation of C++ function libm2k::context::contextOpen.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineArgument(contextOpenDefinition, "uri", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.Context, or clib.array.libm2k.libm2k.context.Context
%validate(contextOpenDefinition);

%% C++ function |libm2k::context::contextOpen| with MATLAB name |clib.libm2k.libm2k.context.contextOpen|
% C++ Signature: libm2k::context::Context * libm2k::context::contextOpen(iio_context * ctx,char const * uri)
%contextOpenDefinition = addFunction(libDef, ...
%    "libm2k::context::Context * libm2k::context::contextOpen(iio_context * ctx,char const * uri)", ...
%    "MATLABName", "clib.libm2k.libm2k.context.contextOpen", ...
%    "Description", "clib.libm2k.libm2k.context.contextOpen    Representation of C++ function libm2k::context::contextOpen.", ...
%    "DetailedDescription", "This content is from the external library documentation." + newline + ...
%    "" + newline + ...
%    "@private"); % Modify help description values as needed.
%defineArgument(contextOpenDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>);
%defineArgument(contextOpenDefinition, "uri", <MLTYPE>, "input", <SHAPE>); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(contextOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.Context", <SHAPE>); % '<MLTYPE>' can be clib.libm2k.libm2k.context.Context, or clib.array.libm2k.libm2k.context.Context
%validate(contextOpenDefinition);

%% C++ function |libm2k::context::m2kOpen| with MATLAB name |clib.libm2k.libm2k.context.m2kOpen|
% C++ Signature: libm2k::context::M2k * libm2k::context::m2kOpen(char const * uri)
%m2kOpenDefinition = addFunction(libDef, ...
%    "libm2k::context::M2k * libm2k::context::m2kOpen(char const * uri)", ...
%    "MATLABName", "clib.libm2k.libm2k.context.m2kOpen", ...
%    "Description", "clib.libm2k.libm2k.context.m2kOpen    Representation of C++ function libm2k::context::m2kOpen." + newline + ...
%    "Open an ADALM2000 based on a given uri", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(m2kOpenDefinition, "uri", <MLTYPE>, "input", <SHAPE>, "Description", "uri Describe the location of the context"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", <SHAPE>, "Description", "M2k object or nullptr if no ADALM2000 was found/available"); % '<MLTYPE>' can be clib.libm2k.libm2k.context.M2k, or clib.array.libm2k.libm2k.context.M2k
%validate(m2kOpenDefinition);

%% C++ function |libm2k::context::m2kOpen| with MATLAB name |clib.libm2k.libm2k.context.m2kOpen|
% C++ Signature: libm2k::context::M2k * libm2k::context::m2kOpen(iio_context * ctx,char const * uri)
%m2kOpenDefinition = addFunction(libDef, ...
%    "libm2k::context::M2k * libm2k::context::m2kOpen(iio_context * ctx,char const * uri)", ...
%    "MATLABName", "clib.libm2k.libm2k.context.m2kOpen", ...
%    "Description", "clib.libm2k.libm2k.context.m2kOpen    Representation of C++ function libm2k::context::m2kOpen." + newline + ...
%    "Open an ADALM2000 based on an existing iio_context and uri", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(m2kOpenDefinition, "ctx", "clib.libm2k.iio_context", "input", <SHAPE>, "Description", "ctx A pointer to an iio_context structure");
%defineArgument(m2kOpenDefinition, "uri", <MLTYPE>, "input", <SHAPE>, "Description", "uri Describe the location of the context"); % '<MLTYPE>' can be clib.array.libm2k.Char,int8,string, or char
%defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", <SHAPE>, "Description", "M2k object or nullptr if no ADALM2000 was found/available"); % '<MLTYPE>' can be clib.libm2k.libm2k.context.M2k, or clib.array.libm2k.libm2k.context.M2k
%validate(m2kOpenDefinition);

%% C++ function |libm2k::context::m2kOpen| with MATLAB name |clib.libm2k.libm2k.context.m2kOpen|
% C++ Signature: libm2k::context::M2k * libm2k::context::m2kOpen()
m2kOpenDefinition = addFunction(libDef, ...
   "libm2k::context::M2k * libm2k::context::m2kOpen()", ...
   "MATLABName", "clib.libm2k.libm2k.context.m2kOpen", ...
   "Description", "clib.libm2k.libm2k.context.m2kOpen    Representation of C++ function libm2k::context::m2kOpen." + newline + ...
   "Open an ADALM2000", ...
   "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(m2kOpenDefinition, "RetVal", "clib.libm2k.libm2k.context.M2k", 1, "Description", "M2k object or nullptr if no ADALM2000 was found/available"); % '<MLTYPE>' can be clib.libm2k.libm2k.context.M2k, or clib.array.libm2k.libm2k.context.M2k
validate(m2kOpenDefinition);

%% C++ function |libm2k::context::contextClose| with MATLAB name |clib.libm2k.libm2k.context.contextClose|
% C++ Signature: void libm2k::context::contextClose(libm2k::context::Context * ctx,bool deinit)
%contextCloseDefinition = addFunction(libDef, ...
%    "void libm2k::context::contextClose(libm2k::context::Context * ctx,bool deinit)", ...
%    "MATLABName", "clib.libm2k.libm2k.context.contextClose", ...
%    "Description", "clib.libm2k.libm2k.context.contextClose    Representation of C++ function libm2k::context::contextClose." + newline + ...
%    "Destroy the given context", ...
%    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
%defineArgument(contextCloseDefinition, "ctx", "clib.libm2k.libm2k.context.Context", "input", <SHAPE>, "Description", "ctx The context to be destroyed"); % '<MLTYPE>' can be clib.libm2k.libm2k.context.Context, or clib.array.libm2k.libm2k.context.Context
%defineArgument(contextCloseDefinition, "deinit", "logical", "Description", "deinit If deinit is set to false, running contexts won't be affected");
%validate(contextCloseDefinition);

%% C++ function |libm2k::context::contextCloseAll| with MATLAB name |clib.libm2k.libm2k.context.contextCloseAll|
% C++ Signature: void libm2k::context::contextCloseAll()
contextCloseAllDefinition = addFunction(libDef, ...
    "void libm2k::context::contextCloseAll()", ...
    "MATLABName", "clib.libm2k.libm2k.context.contextCloseAll", ...
    "Description", "clib.libm2k.libm2k.context.contextCloseAll    Representation of C++ function libm2k::context::contextCloseAll." + newline + ...
    "Close all the devices", ...
    "DetailedDescription", "This content is from the external library documentation." + newline + ...
    "" + newline + ...
    "@brief Close all the devices"); % Modify help description values as needed.
validate(contextCloseAllDefinition);

%% C++ function |libm2k::context::getVersion| with MATLAB name |clib.libm2k.libm2k.context.getVersion|
% C++ Signature: std::string libm2k::context::getVersion()
getVersionDefinition = addFunction(libDef, ...
    "std::string libm2k::context::getVersion()", ...
    "MATLABName", "clib.libm2k.libm2k.context.getVersion", ...
    "Description", "clib.libm2k.libm2k.context.getVersion    Representation of C++ function libm2k::context::getVersion." + newline + ...
    "Get library version", ...
    "DetailedDescription", "This content is from the external library documentation."); % Modify help description values as needed.
defineOutput(getVersionDefinition, "RetVal", "string", "Description", "a string containing the libm2k version");
validate(getVersionDefinition);

%% Validate the library definition
validate(libDef);

end