nirfmxvna 26.3.0__py3-none-any.whl

nirfmxvna/internal/_library_interpreter.py

@@ -0,0 +1,3011 @@
+"""Library C<->Python interpreter.
+
+This class is responsible for interpreting the Library's C API. It is responsible for:
+* Converting ctypes to native Python types.
+* Dealing with string encoding.
+* Allocating memory.
+* Converting errors returned by Library into Python exceptions.
+"""
+
+import array
+import ctypes
+import math
+from typing import Any
+
+import nirfmxinstr
+import nirfmxvna.attributes as attributes
+import nirfmxvna.enums as enums
+import nirfmxvna.errors as errors
+import nirfmxvna.internal._custom_types as _custom_types
+import nirfmxvna.internal._helper as _helper
+import nirfmxvna.internal._library_singleton as _library_singleton
+import numpy
+
+
+# Helper functions for creating ctypes needed for calling into the driver DLL
+def _get_ctypes_pointer_for_buffer(
+    value: Any = None, library_type: Any = None, size: Any = None
+) -> Any:
+    if isinstance(value, array.array):
+        assert library_type is not None, "library_type is required for array.array"
+        addr, _ = value.buffer_info()
+        return ctypes.cast(addr, ctypes.POINTER(library_type))
+    elif str(type(value)).find("'numpy.ndarray'") != -1:
+        import numpy
+
+        if "complex" in str(value.dtype):
+            complex_dtype = numpy.dtype(library_type)
+            structured_array = value.view(complex_dtype)
+            return structured_array.ctypes.data_as(ctypes.POINTER(library_type))
+        else:
+            return numpy.ctypeslib.as_ctypes(value)
+    elif isinstance(value, bytes):
+        return ctypes.cast(value, ctypes.POINTER(library_type))  # type: ignore
+    elif isinstance(value, list):
+        assert library_type is not None, "library_type is required for list"
+        return (library_type * len(value))(*value)
+    else:
+        if library_type is not None and size is not None:
+            return (library_type * size)()
+        else:
+            return None
+
+
+def _convert_to_array(value: Any, array_type: Any) -> Any:
+    if value is not None:
+        if isinstance(value, array.array):
+            value_array = value
+        else:
+            value_array = array.array(array_type, value)
+    else:
+        value_array = None
+
+    return value_array
+
+
+class LibraryInterpreter(object):
+    """Library C<->Python interpreter.
+
+    This class is responsible for interpreting the Library's C API. It is responsible for:
+    * Converting ctypes to native Python types.
+    * Dealing with string encoding.
+    * Allocating memory.
+    * Converting errors returned by Library into Python exceptions.
+    """
+
+    _cls_encoding = "windows-1251"
+    _cls_library = _library_singleton.get()
+
+    def __init__(self, encoding, session=None, signal_obj=None):
+        """Initializes the LibraryInterpreter."""
+        self._encoding = encoding
+        self._library = _library_singleton.get()
+        self._signal_obj = signal_obj
+        self._instr_session = session
+        # Initialize _vi to 0 for now.
+        # Session will directly update it once the driver runtime init function has been called and
+        # we have a valid session handle.
+        self.set_session_handle()
+
+    def set_session_handle(self, value: Any = 0) -> None:
+        """Sets the session handle."""
+        self._vi = value
+
+    def get_session_handle(self) -> Any:
+        """Returns the session handle."""
+        return self._vi
+
+    def get_error_string(self, error_code: int) -> Any:
+        """Returns the error message."""
+        error_code_ctype = ctypes.c_int32(error_code)
+        error_string_ctype = ctypes.create_string_buffer(0)
+        size_or_error_code = self._library.RFmxVNA_GetErrorString(
+            self._vi, error_code_ctype, 0, None
+        )
+        if size_or_error_code > 0 and error_code_ctype.value != 0:
+            error_string_ctype = ctypes.create_string_buffer(size_or_error_code)
+            self._library.RFmxVNA_GetErrorString(
+                self._vi, error_code_ctype, size_or_error_code, error_string_ctype
+            )
+        return error_string_ctype.value.decode(self._encoding)
+
+    def get_error(self) -> tuple[int, Any]:
+        """Returns the error code and error message."""
+        error_code_ctype = ctypes.c_int32()
+        error_string_ctype = ctypes.create_string_buffer(0)
+        size_or_error_code = self._library.RFmxVNA_GetError(self._vi, error_code_ctype, 0, None)
+        if size_or_error_code > 0 and error_code_ctype.value != 0:
+            error_code_ctype = ctypes.c_int32(error_code_ctype.value)
+            error_string_ctype = ctypes.create_string_buffer(size_or_error_code)
+            self._library.RFmxVNA_GetError(
+                self._vi, error_code_ctype, size_or_error_code, error_string_ctype
+            )
+        return error_code_ctype.value, error_string_ctype.value.decode(self._encoding)
+
+    def get_error_description(self, error_code: Any) -> Any:
+        """Returns the error description."""
+        try:
+            returned_error_code, error_string = self.get_error()
+            if returned_error_code == error_code:
+                return error_string
+        except errors.Error:
+            pass
+
+        try:
+            """
+            It is expected for get_error to raise when the session is invalid
+            Use get_error_string instead. It doesn't require a session.
+            """
+            error_string = self.get_error_string(error_code)
+            return error_string
+        except errors.Error:
+            pass
+        return "Failed to retrieve error description."
+
+    def reset_attribute(self, selector_string, attribute_id):
+        """reset_attribute."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_int32(attribute_id)
+        error_code = self._library.RFmxVNA_ResetAttribute(
+            vi_ctype, selector_string_ctype, attribute_id_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def check_if_current_signal_exists(self):
+        """check_if_current_signal_exists."""
+        return_value = False
+        if self._signal_obj is not None and not self._signal_obj.signal_configuration_name:
+            signal_configuration_exists, local_personality, _ = (
+                self._signal_obj._rfmxinstrsession_interpreter.check_if_signal_exists(
+                    self._signal_obj._default_signal_name_user_visible
+                )
+            )
+            return_value = signal_configuration_exists and (
+                local_personality.value == nirfmxinstr.Personalities.VNA.value
+            )
+        elif self._signal_obj is not None:
+            signal_configuration_exists, local_personality, _ = (
+                self._signal_obj._rfmxinstrsession_interpreter.check_if_signal_exists(
+                    self._signal_obj.signal_configuration_name
+                )
+            )
+            return_value = signal_configuration_exists and (
+                local_personality.value == nirfmxinstr.Personalities.VNA.value
+            )
+        return return_value
+
+    def get_attribute_i8(self, selector_string, attribute_id):
+        """get_attribute_i8."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_int8()
+        error_code = self._library.RFmxVNA_GetAttributeI8(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            None if attr_val_ctype is None else (ctypes.pointer(attr_val_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value, error_code
+
+    def set_attribute_i8(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i8."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_int8(attr_val)
+        error_code = self._library.RFmxVNA_SetAttributeI8(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_i8_array(self, selector_string, attribute_id):
+        """get_attribute_i8_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeI8Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.int8)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_int8
+        )
+        error_code = self._library.RFmxVNA_GetAttributeI8Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_i8_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i8_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="i")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_int8
+        )
+        error_code = self._library.RFmxVNA_SetAttributeI8Array(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_i16(self, selector_string, attribute_id):
+        """get_attribute_i16."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_int16()
+        error_code = self._library.RFmxVNA_GetAttributeI16(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            None if attr_val_ctype is None else (ctypes.pointer(attr_val_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value, error_code
+
+    def set_attribute_i16(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i16."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_int16(attr_val)
+        error_code = self._library.RFmxVNA_SetAttributeI16(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_i32(self, selector_string, attribute_id):
+        """get_attribute_i32."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeI32(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            None if attr_val_ctype is None else (ctypes.pointer(attr_val_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value, error_code
+
+    def set_attribute_i32(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i32."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_int32(attr_val)
+        error_code = self._library.RFmxVNA_SetAttributeI32(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_i32_array(self, selector_string, attribute_id):
+        """get_attribute_i32_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeI32Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.int32)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_int32
+        )
+        error_code = self._library.RFmxVNA_GetAttributeI32Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_i32_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i32_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="i")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_int32
+        )
+        error_code = self._library.RFmxVNA_SetAttributeI32Array(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_i64(self, selector_string, attribute_id):
+        """get_attribute_i64."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_int64()
+        error_code = self._library.RFmxVNA_GetAttributeI64(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            None if attr_val_ctype is None else (ctypes.pointer(attr_val_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value, error_code
+
+    def set_attribute_i64(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i64."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_int64(attr_val)
+        error_code = self._library.RFmxVNA_SetAttributeI64(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_i64_array(self, selector_string, attribute_id):
+        """get_attribute_i64_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeI64Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.int64)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_int64
+        )
+        error_code = self._library.RFmxVNA_GetAttributeI64Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_i64_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i64_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="i")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_int64
+        )
+        error_code = self._library.RFmxVNA_SetAttributeI64Array(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_u8(self, selector_string, attribute_id):
+        """get_attribute_u8."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_uint8()
+        error_code = self._library.RFmxVNA_GetAttributeU8(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            None if attr_val_ctype is None else (ctypes.pointer(attr_val_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value, error_code
+
+    def set_attribute_u8(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u8."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_uint8(attr_val)
+        error_code = self._library.RFmxVNA_SetAttributeU8(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_u8_array(self, selector_string, attribute_id):
+        """get_attribute_u8_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeU8Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.uint8)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_uint8
+        )
+        error_code = self._library.RFmxVNA_GetAttributeU8Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_u8_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u8_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="i")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_uint8
+        )
+        error_code = self._library.RFmxVNA_SetAttributeU8Array(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_u16(self, selector_string, attribute_id):
+        """get_attribute_u16."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_uint16()
+        error_code = self._library.RFmxVNA_GetAttributeU16(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            None if attr_val_ctype is None else (ctypes.pointer(attr_val_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value, error_code
+
+    def set_attribute_u16(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u16."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_uint16(attr_val)
+        error_code = self._library.RFmxVNA_SetAttributeU16(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_u32(self, selector_string, attribute_id):
+        """get_attribute_u32."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_uint32()
+        error_code = self._library.RFmxVNA_GetAttributeU32(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            None if attr_val_ctype is None else (ctypes.pointer(attr_val_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value, error_code
+
+    def set_attribute_u32(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u32."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_uint32(attr_val)
+        error_code = self._library.RFmxVNA_SetAttributeU32(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_u32_array(self, selector_string, attribute_id):
+        """get_attribute_u32_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeU32Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.uint32)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_uint32
+        )
+        error_code = self._library.RFmxVNA_GetAttributeU32Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_u32_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u32_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="i")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_uint32
+        )
+        error_code = self._library.RFmxVNA_SetAttributeU32Array(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_u64_array(self, selector_string, attribute_id):
+        """get_attribute_u64_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeU64Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.uint64)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_uint64
+        )
+        error_code = self._library.RFmxVNA_GetAttributeU64Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_u64_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u64_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="i")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_uint64
+        )
+        error_code = self._library.RFmxVNA_SetAttributeU64Array(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_f32(self, selector_string, attribute_id):
+        """get_attribute_f32."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_float()
+        error_code = self._library.RFmxVNA_GetAttributeF32(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            None if attr_val_ctype is None else (ctypes.pointer(attr_val_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value, error_code
+
+    def set_attribute_f32(self, selector_string, attribute_id, attr_val):
+        """set_attribute_f32."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_float(attr_val)
+        error_code = self._library.RFmxVNA_SetAttributeF32(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_f32_array(self, selector_string, attribute_id):
+        """get_attribute_f32_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeF32Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.float32)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_float
+        )
+        error_code = self._library.RFmxVNA_GetAttributeF32Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_f32_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_f32_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="f")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_float
+        )
+        error_code = self._library.RFmxVNA_SetAttributeF32Array(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_f64(self, selector_string, attribute_id):
+        """get_attribute_f64."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_GetAttributeF64(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            None if attr_val_ctype is None else (ctypes.pointer(attr_val_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value, error_code
+
+    def set_attribute_f64(self, selector_string, attribute_id, attr_val):
+        """set_attribute_f64."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.c_double(attr_val)
+        error_code = self._library.RFmxVNA_SetAttributeF64(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_f64_array(self, selector_string, attribute_id):
+        """get_attribute_f64_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeF64Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.float64)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_double
+        )
+        error_code = self._library.RFmxVNA_GetAttributeF64Array(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_f64_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_f64_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="d")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_double
+        )
+        error_code = self._library.RFmxVNA_SetAttributeF64Array(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_nicomplexsingle_array(self, selector_string, attribute_id):
+        """get_attribute_nicomplexsingle_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeNIComplexSingleArray(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.complex64)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_float
+        )
+        error_code = self._library.RFmxVNA_GetAttributeNIComplexSingleArray(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_nicomplexsingle_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_nicomplexsingle_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_float
+        )
+        error_code = self._library.RFmxVNA_SetAttributeNIComplexSingleArray(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_nicomplexdouble_array(self, selector_string, attribute_id):
+        """get_attribute_nicomplexdouble_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = None
+        array_size_ctype = ctypes.c_int32()
+        actual_array_size_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_GetAttributeNIComplexDoubleArray(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            array_size_ctype,
+            None if actual_array_size_ctype is None else (ctypes.pointer(actual_array_size_ctype)),
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        attr_val_array = numpy.empty(actual_array_size_ctype.value, dtype=numpy.complex128)
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_double
+        )
+        error_code = self._library.RFmxVNA_GetAttributeNIComplexDoubleArray(
+            vi_ctype,
+            selector_string_ctype,
+            attribute_id_ctype,
+            attr_val_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_array, error_code
+
+    def set_attribute_nicomplexdouble_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_nicomplexdouble_array."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_array = _convert_to_array(value=attr_val, array_type="")
+        attr_val_ctype = _get_ctypes_pointer_for_buffer(
+            value=attr_val_array, library_type=ctypes.c_double
+        )
+        error_code = self._library.RFmxVNA_SetAttributeNIComplexDoubleArray(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype, len(attr_val)
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_attribute_string(self, selector_string, attribute_id):
+        """get_attribute_string."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        array_size_ctype = ctypes.c_int32(0)
+        attr_val_ctype = None
+        size_or_error_code = self._library.RFmxVNA_GetAttributeString(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, array_size_ctype, attr_val_ctype
+        )
+        if size_or_error_code < 0:
+            errors.handle_error(
+                self, size_or_error_code, ignore_warnings=True, is_error_handling=False
+            )
+            return None, size_or_error_code
+        array_size_ctype = ctypes.c_int32(size_or_error_code)
+        attr_val_ctype = (ctypes.c_char * array_size_ctype.value)()
+        error_code = self._library.RFmxVNA_GetAttributeString(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, array_size_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return attr_val_ctype.value.decode(self._encoding), error_code
+
+    def set_attribute_string(self, selector_string, attribute_id, attr_val):
+        """set_attribute_string."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        attribute_id_ctype = ctypes.c_uint32(attribute_id)
+        attr_val_ctype = ctypes.create_string_buffer(attr_val.encode(self._encoding))
+        error_code = self._library.RFmxVNA_SetAttributeString(
+            vi_ctype, selector_string_ctype, attribute_id_ctype, attr_val_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def s_params_configure_s_parameter(self, selector_string, s_parameter):
+        """s_params_configure_s_parameter."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        s_parameter_ctype = ctypes.create_string_buffer(s_parameter.encode(self._encoding))
+        error_code = self._library.RFmxVNA_SParamsCfgSParameter(
+            vi_ctype, selector_string_ctype, s_parameter_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def s_params_export_to_snp_file(self, selector_string, snp_file_path):
+        """s_params_export_to_snp_file."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        snp_file_path_ctype = ctypes.create_string_buffer(snp_file_path.encode(self._encoding))
+        error_code = self._library.RFmxVNA_SParamsExportToSnPFile(
+            vi_ctype, selector_string_ctype, snp_file_path_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def waves_configure_wave(self, selector_string, wave):
+        """waves_configure_wave."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        wave_ctype = ctypes.create_string_buffer(wave.encode(self._encoding))
+        error_code = self._library.RFmxVNA_WavesCfgWave(vi_ctype, selector_string_ctype, wave_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def abort_measurements(self, selector_string):
+        """abort_measurements."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_AbortMeasurements(vi_ctype, selector_string_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calibration_initiate(self, selector_string):
+        """calibration_initiate."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalibrationInitiate(vi_ctype, selector_string_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calibration_acquire(self, selector_string, timeout):
+        """calibration_acquire."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        timeout_ctype = ctypes.c_double(timeout)
+        error_code = self._library.RFmxVNA_CalibrationAcquire(
+            vi_ctype, selector_string_ctype, timeout_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calibration_abort(self, selector_string):
+        """calibration_abort."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalibrationAbort(vi_ctype, selector_string_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calibration_save(self, selector_string, calset_name):
+        """calibration_save."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calset_name_ctype = ctypes.create_string_buffer(calset_name.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalibrationSave(
+            vi_ctype, selector_string_ctype, calset_name_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def clear_calset(self, selector_string, calset_name):
+        """clear_calset."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calset_name_ctype = ctypes.create_string_buffer(calset_name.encode(self._encoding))
+        error_code = self._library.RFmxVNA_ClearCalset(
+            vi_ctype, selector_string_ctype, calset_name_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calset_load_from_file(self, selector_string, calset_name, calset_file_path):
+        """calset_load_from_file."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calset_name_ctype = ctypes.create_string_buffer(calset_name.encode(self._encoding))
+        calset_file_path_ctype = ctypes.create_string_buffer(
+            calset_file_path.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_CalsetLoadFromFile(
+            vi_ctype, selector_string_ctype, calset_name_ctype, calset_file_path_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calset_save_to_file(self, selector_string, calset_name, calset_file_path):
+        """calset_save_to_file."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calset_name_ctype = ctypes.create_string_buffer(calset_name.encode(self._encoding))
+        calset_file_path_ctype = ctypes.create_string_buffer(
+            calset_file_path.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_CalsetSaveToFile(
+            vi_ctype, selector_string_ctype, calset_name_ctype, calset_file_path_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def auto_detect_vcal_orientation(self, selector_string):
+        """auto_detect_vcal_orientation."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_AutoDetectvCalOrientation(
+            vi_ctype, selector_string_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def check_measurement_status(self, selector_string):
+        """check_measurement_status."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        is_done_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_CheckMeasurementStatus(
+            vi_ctype, selector_string_ctype, is_done_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return bool(is_done_ctype.value), error_code
+
+    def clear_all_named_results(self, selector_string):
+        """clear_all_named_results."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_ClearAllNamedResults(vi_ctype, selector_string_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def clear_named_result(self, selector_string):
+        """clear_named_result."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_ClearNamedResult(vi_ctype, selector_string_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def copy_calset(self, selector_string, source_calset_name, new_calset_name):
+        """copy_calset."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        source_calset_name_ctype = ctypes.create_string_buffer(
+            source_calset_name.encode(self._encoding)
+        )
+        new_calset_name_ctype = ctypes.create_string_buffer(new_calset_name.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CopyCalset(
+            vi_ctype, selector_string_ctype, source_calset_name_ctype, new_calset_name_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def select_active_calset(self, selector_string, calset_name, restore_configuration):
+        """select_active_calset."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calset_name_ctype = ctypes.create_string_buffer(calset_name.encode(self._encoding))
+        restore_configuration_ctype = ctypes.c_int32(restore_configuration)
+        error_code = self._library.RFmxVNA_SelectActiveCalset(
+            vi_ctype, selector_string_ctype, calset_name_ctype, restore_configuration_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_all_calset_names(self, selector_string):
+        """get_all_calset_names."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        array_size_ctype = ctypes.c_int32(0)
+        error_code = self._library.RFmxVNA_GetAllCalsetNames(
+            vi_ctype, selector_string_ctype, array_size_ctype, None
+        )
+        if error_code < 0:
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+            return "", error_code
+        calset_names_ctype = ctypes.create_string_buffer(error_code)
+
+        error_code = self._library.RFmxVNA_GetAllCalsetNames(
+            vi_ctype, selector_string_ctype, error_code, calset_names_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return calset_names_ctype.value.decode(self._encoding), error_code
+
+    def commit(self, selector_string):
+        """commit."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_Commit(vi_ctype, selector_string_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def create_signal_configuration(self, signal_name):
+        """create_signal_configuration."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        signal_name_ctype = ctypes.create_string_buffer(signal_name.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CreateSignalConfiguration(vi_ctype, signal_name_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def initiate(self, selector_string, result_name):
+        """initiate."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        result_name_ctype = ctypes.create_string_buffer(result_name.encode(self._encoding))
+        error_code = self._library.RFmxVNA_Initiate(
+            vi_ctype, selector_string_ctype, result_name_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def reset_to_default(self, selector_string):
+        """reset_to_default."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_ResetToDefault(vi_ctype, selector_string_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def select_measurements(self, selector_string, measurements, enable_all_traces):
+        """select_measurements."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        measurements_ctype = ctypes.c_uint32(measurements)
+        enable_all_traces_ctype = ctypes.c_int32(enable_all_traces)
+        error_code = self._library.RFmxVNA_SelectMeasurements(
+            vi_ctype, selector_string_ctype, measurements_ctype, enable_all_traces_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def wait_for_measurement_complete(self, selector_string, timeout):
+        """wait_for_measurement_complete."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        timeout_ctype = ctypes.c_double(timeout)
+        error_code = self._library.RFmxVNA_WaitForMeasurementComplete(
+            vi_ctype, selector_string_ctype, timeout_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calset_embed_fixture_s2p(
+        self,
+        selector_string,
+        calset_name,
+        fixture_s2p_file_path,
+        vna_port,
+        s_parameter_orientation,
+        new_calset_name,
+    ):
+        """calset_embed_fixture_s2p."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calset_name_ctype = ctypes.create_string_buffer(calset_name.encode(self._encoding))
+        fixture_s2p_file_path_ctype = ctypes.create_string_buffer(
+            fixture_s2p_file_path.encode(self._encoding)
+        )
+        vna_port_ctype = ctypes.create_string_buffer(vna_port.encode(self._encoding))
+        s_parameter_orientation_ctype = ctypes.c_int32(s_parameter_orientation)
+        new_calset_name_ctype = ctypes.create_string_buffer(new_calset_name.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalsetEmbedFixtureS2p(
+            vi_ctype,
+            selector_string_ctype,
+            calset_name_ctype,
+            fixture_s2p_file_path_ctype,
+            vna_port_ctype,
+            s_parameter_orientation_ctype,
+            new_calset_name_ctype,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def deselect_active_calset(self, selector_string):
+        """deselect_active_calset."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_DeselectActiveCalset(vi_ctype, selector_string_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def load_data_to_measurement_memory_from_file(
+        self, selector_string, file_path, parameter, measurement_memory_name
+    ):
+        """load_data_to_measurement_memory_from_file."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        file_path_ctype = ctypes.create_string_buffer(file_path.encode(self._encoding))
+        parameter_ctype = ctypes.create_string_buffer(parameter.encode(self._encoding))
+        measurement_memory_name_ctype = ctypes.create_string_buffer(
+            measurement_memory_name.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_LoadDataToMeasurementMemoryFromFile(
+            vi_ctype,
+            selector_string_ctype,
+            file_path_ctype,
+            parameter_ctype,
+            measurement_memory_name_ctype,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def copy_data_to_measurement_memory(self, selector_string, measurement_memory_name):
+        """copy_data_to_measurement_memory."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        measurement_memory_name_ctype = ctypes.create_string_buffer(
+            measurement_memory_name.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_CopyDataToMeasurementMemory(
+            vi_ctype, selector_string_ctype, measurement_memory_name_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_measurement_memory_names(self, selector_string):
+        """get_measurement_memory_names."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        array_size_ctype = ctypes.c_int32(0)
+        error_code = self._library.RFmxVNA_GetMeasurementMemoryNames(
+            vi_ctype, selector_string_ctype, array_size_ctype, None
+        )
+        if error_code < 0:
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+            return "", error_code
+        measurement_memory_names_ctype = ctypes.create_string_buffer(error_code)
+
+        error_code = self._library.RFmxVNA_GetMeasurementMemoryNames(
+            vi_ctype, selector_string_ctype, error_code, measurement_memory_names_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return measurement_memory_names_ctype.value.decode(self._encoding), error_code
+
+    def clear_measurement_memory_names(self, selector_string):
+        """clear_measurement_memory_names."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        error_code = self._library.RFmxVNA_ClearMeasurementMemoryNames(
+            vi_ctype, selector_string_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def auto_port_extension_measure(self, selector_string, standard, port):
+        """auto_port_extension_measure."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        standard_ctype = ctypes.c_int32(standard)
+        port_ctype = ctypes.create_string_buffer(port.encode(self._encoding))
+        error_code = self._library.RFmxVNA_AutoPortExtensionMeasure(
+            vi_ctype, selector_string_ctype, standard_ctype, port_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_import_calkit(self, selector_string, calkit_file_path):
+        """calkit_manager_import_calkit."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calkit_file_path_ctype = ctypes.create_string_buffer(
+            calkit_file_path.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_CalkitManagerImportCalkit(
+            vi_ctype, selector_string_ctype, calkit_file_path_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_export_calkit(self, selector_string, calkit_id, calkit_file_path):
+        """calkit_manager_export_calkit."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calkit_id_ctype = ctypes.create_string_buffer(calkit_id.encode(self._encoding))
+        calkit_file_path_ctype = ctypes.create_string_buffer(
+            calkit_file_path.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_CalkitManagerExportCalkit(
+            vi_ctype, selector_string_ctype, calkit_id_ctype, calkit_file_path_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_create_calkit(self, selector_string, calkit_id):
+        """calkit_manager_create_calkit."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calkit_id_ctype = ctypes.create_string_buffer(calkit_id.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalkitManagerCreateCalkit(
+            vi_ctype, selector_string_ctype, calkit_id_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_remove_calkit(self, selector_string, calkit_id):
+        """calkit_manager_remove_calkit."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calkit_id_ctype = ctypes.create_string_buffer(calkit_id.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalkitManagerRemoveCalkit(
+            vi_ctype, selector_string_ctype, calkit_id_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_validate_calkit(self, selector_string, calkit_id):
+        """calkit_manager_validate_calkit."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calkit_id_ctype = ctypes.create_string_buffer(calkit_id.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalkitManagerValidateCalkit(
+            vi_ctype, selector_string_ctype, calkit_id_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_get_calkit_ids(self, selector_string):
+        """calkit_manager_get_calkit_ids."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        array_size_ctype = ctypes.c_int32(0)
+        error_code = self._library.RFmxVNA_CalkitManagerGetCalkitIDs(
+            vi_ctype, selector_string_ctype, array_size_ctype, None
+        )
+        if error_code < 0:
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+            return "", error_code
+        calkit_ids_ctype = ctypes.create_string_buffer(error_code)
+
+        error_code = self._library.RFmxVNA_CalkitManagerGetCalkitIDs(
+            vi_ctype, selector_string_ctype, error_code, calkit_ids_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return calkit_ids_ctype.value.decode(self._encoding), error_code
+
+    def calkit_manager_calkit_add_connector(self, selector_string, connector_id):
+        """calkit_manager_calkit_add_connector."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        connector_id_ctype = ctypes.create_string_buffer(connector_id.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitAddConnector(
+            vi_ctype, selector_string_ctype, connector_id_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_remove_connector(self, selector_string, connector_id):
+        """calkit_manager_calkit_remove_connector."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        connector_id_ctype = ctypes.create_string_buffer(connector_id.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitRemoveConnector(
+            vi_ctype, selector_string_ctype, connector_id_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_get_connector_ids(self, selector_string):
+        """calkit_manager_calkit_get_connector_ids."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        array_size_ctype = ctypes.c_int32(0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitGetConnectorIDs(
+            vi_ctype, selector_string_ctype, array_size_ctype, None
+        )
+        if error_code < 0:
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+            return "", error_code
+        connector_ids_ctype = ctypes.create_string_buffer(error_code)
+
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitGetConnectorIDs(
+            vi_ctype, selector_string_ctype, error_code, connector_ids_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return connector_ids_ctype.value.decode(self._encoding), error_code
+
+    def calkit_manager_calkit_add_calibration_element(
+        self, selector_string, calibration_element_id
+    ):
+        """calkit_manager_calkit_add_calibration_element."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calibration_element_id_ctype = ctypes.create_string_buffer(
+            calibration_element_id.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitAddCalibrationElement(
+            vi_ctype, selector_string_ctype, calibration_element_id_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_remove_calibration_element(
+        self, selector_string, calibration_element_id
+    ):
+        """calkit_manager_calkit_remove_calibration_element."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calibration_element_id_ctype = ctypes.create_string_buffer(
+            calibration_element_id.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitRemoveCalibrationElement(
+            vi_ctype, selector_string_ctype, calibration_element_id_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_get_calibration_element_ids(self, selector_string):
+        """calkit_manager_calkit_get_calibration_element_ids."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        array_size_ctype = ctypes.c_int32(0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitGetCalibrationElementIDs(
+            vi_ctype, selector_string_ctype, array_size_ctype, None
+        )
+        if error_code < 0:
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+            return "", error_code
+        calibration_element_ids_ctype = ctypes.create_string_buffer(error_code)
+
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitGetCalibrationElementIDs(
+            vi_ctype, selector_string_ctype, error_code, calibration_element_ids_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return calibration_element_ids_ctype.value.decode(self._encoding), error_code
+
+    def calkit_manager_calkit_set_description(self, selector_string, calkit_description):
+        """calkit_manager_calkit_set_description."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calkit_description_ctype = ctypes.create_string_buffer(
+            calkit_description.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitSetDescription(
+            vi_ctype, selector_string_ctype, calkit_description_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_set_version(self, selector_string, calkit_version):
+        """calkit_manager_calkit_set_version."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calkit_version_ctype = ctypes.create_string_buffer(calkit_version.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitSetVersion(
+            vi_ctype, selector_string_ctype, calkit_version_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_set_trl_reference_plane(self, selector_string, reference_plane):
+        """calkit_manager_calkit_set_trl_reference_plane."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        reference_plane_ctype = ctypes.c_int32(reference_plane)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitSetTRLReferencePlane(
+            vi_ctype, selector_string_ctype, reference_plane_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_set_lrl_line_auto_char(
+        self, selector_string, auto_characterization_enabled
+    ):
+        """calkit_manager_calkit_set_lrl_line_auto_char."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        auto_characterization_enabled_ctype = ctypes.c_int32(auto_characterization_enabled)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitSetLRLLineAutoChar(
+            vi_ctype, selector_string_ctype, auto_characterization_enabled_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_connector_set_description(self, selector_string, description):
+        """calkit_manager_calkit_connector_set_description."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        description_ctype = ctypes.create_string_buffer(description.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorSetDescription(
+            vi_ctype, selector_string_ctype, description_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_connector_set_gender(self, selector_string, connector_gender):
+        """calkit_manager_calkit_connector_set_gender."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        connector_gender_ctype = ctypes.c_int32(connector_gender)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorSetGender(
+            vi_ctype, selector_string_ctype, connector_gender_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_connector_set_type(self, selector_string, connector_type):
+        """calkit_manager_calkit_connector_set_type."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        connector_type_ctype = ctypes.create_string_buffer(connector_type.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorSetType(
+            vi_ctype, selector_string_ctype, connector_type_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_connector_set_impedance(self, selector_string, impedance):
+        """calkit_manager_calkit_connector_set_impedance."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        impedance_ctype = ctypes.c_double(impedance)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorSetImpedance(
+            vi_ctype, selector_string_ctype, impedance_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_connector_set_minimum_frequency(
+        self, selector_string, minimum_frequency
+    ):
+        """calkit_manager_calkit_connector_set_minimum_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        minimum_frequency_ctype = ctypes.c_double(minimum_frequency)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorSetMinimumFrequency(
+            vi_ctype, selector_string_ctype, minimum_frequency_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_connector_set_maximum_frequency(
+        self, selector_string, maximum_frequency
+    ):
+        """calkit_manager_calkit_connector_set_maximum_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        maximum_frequency_ctype = ctypes.c_double(maximum_frequency)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorSetMaximumFrequency(
+            vi_ctype, selector_string_ctype, maximum_frequency_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_set_description(
+        self, selector_string, description
+    ):
+        """calkit_manager_calkit_calibration_element_set_description."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        description_ctype = ctypes.create_string_buffer(description.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSetDescription(
+            vi_ctype, selector_string_ctype, description_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_set_types(
+        self, selector_string, calibration_element_types
+    ):
+        """calkit_manager_calkit_calibration_element_set_types."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calibration_element_types_ctype = _get_ctypes_pointer_for_buffer(
+            value=calibration_element_types, library_type=ctypes.c_int32
+        )
+        array_size_ctype = ctypes.c_int32(
+            len(calibration_element_types) if calibration_element_types is not None else 0
+        )
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSetTypes(
+            vi_ctype, selector_string_ctype, calibration_element_types_ctype, array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_get_port_connectors(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_port_connectors."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        array_size_ctype = ctypes.c_int32(0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementGetPortConnectors(
+            vi_ctype, selector_string_ctype, array_size_ctype, None
+        )
+        if error_code < 0:
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+            return "", error_code
+        connector_ids_ctype = ctypes.create_string_buffer(error_code)
+
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementGetPortConnectors(
+            vi_ctype, selector_string_ctype, error_code, connector_ids_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return connector_ids_ctype.value.decode(self._encoding), error_code
+
+    def calkit_manager_calkit_calibration_element_set_s_parameter_definition(
+        self, selector_string, s_parameter_definition
+    ):
+        """calkit_manager_calkit_calibration_element_set_s_parameter_definition."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        s_parameter_definition_ctype = ctypes.c_int32(s_parameter_definition)
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSetSParameterDefinition(
+                vi_ctype, selector_string_ctype, s_parameter_definition_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_set_minimum_frequency(
+        self, selector_string, minimum_frequency
+    ):
+        """calkit_manager_calkit_calibration_element_set_minimum_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        minimum_frequency_ctype = ctypes.c_double(minimum_frequency)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSetMinimumFrequency(
+            vi_ctype, selector_string_ctype, minimum_frequency_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_set_maximum_frequency(
+        self, selector_string, maximum_frequency
+    ):
+        """calkit_manager_calkit_calibration_element_set_maximum_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        maximum_frequency_ctype = ctypes.c_double(maximum_frequency)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSetMaximumFrequency(
+            vi_ctype, selector_string_ctype, maximum_frequency_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_model_type(
+        self, selector_string, model_type
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_model_type."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        model_type_ctype = ctypes.c_int32(model_type)
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetModelType(
+                vi_ctype, selector_string_ctype, model_type_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_s_param_availability(
+        self, selector_string, s_parameter_availability
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_s_param_availability."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        s_parameter_availability_ctype = ctypes.c_int32(s_parameter_availability)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetSParamAvailability(
+            vi_ctype, selector_string_ctype, s_parameter_availability_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_c0(self, selector_string, c0):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_c0."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        c0_ctype = ctypes.c_double(c0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetC0(
+            vi_ctype, selector_string_ctype, c0_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_c1(self, selector_string, c1):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_c1."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        c1_ctype = ctypes.c_double(c1)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetC1(
+            vi_ctype, selector_string_ctype, c1_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_c2(self, selector_string, c2):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_c2."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        c2_ctype = ctypes.c_double(c2)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetC2(
+            vi_ctype, selector_string_ctype, c2_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_c3(self, selector_string, c3):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_c3."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        c3_ctype = ctypes.c_double(c3)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetC3(
+            vi_ctype, selector_string_ctype, c3_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_offset_delay(
+        self, selector_string, offset_delay
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_offset_delay."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        offset_delay_ctype = ctypes.c_double(offset_delay)
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetOffsetDelay(
+                vi_ctype, selector_string_ctype, offset_delay_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_offset_loss(
+        self, selector_string, offset_loss
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_offset_loss."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        offset_loss_ctype = ctypes.c_double(offset_loss)
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetOffsetLoss(
+                vi_ctype, selector_string_ctype, offset_loss_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_offset_z0(
+        self, selector_string, offset_z0
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_offset_z0."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        offset_z0_ctype = ctypes.c_double(offset_z0)
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetOffsetZ0(
+                vi_ctype, selector_string_ctype, offset_z0_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_reference_impedance(
+        self, selector_string, reference_impedance
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_reference_impedance."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        reference_impedance_ctype = ctypes.c_double(reference_impedance)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelSetReferenceImpedance(
+            vi_ctype, selector_string_ctype, reference_impedance_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_delay_model_set_delay(
+        self, selector_string, delay
+    ):
+        """calkit_manager_calkit_calibration_element_delay_model_set_delay."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        delay_ctype = ctypes.c_double(delay)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementDelayModelSetDelay(
+            vi_ctype, selector_string_ctype, delay_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_frequency(
+        self, selector_string, frequency
+    ):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        frequency_ctype = _get_ctypes_pointer_for_buffer(
+            value=frequency, library_type=ctypes.c_double
+        )
+        array_size_ctype = ctypes.c_int32(len(frequency) if frequency is not None else 0)
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterSetFrequency(
+                vi_ctype, selector_string_ctype, frequency_ctype, array_size_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s_param_availability(
+        self, selector_string, s_parameter_availability
+    ):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s_param_availability."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        s_parameter_availability_ctype = ctypes.c_int32(s_parameter_availability)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterSetSParamAvailability(
+            vi_ctype, selector_string_ctype, s_parameter_availability_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s11(self, selector_string, s11):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s11."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        _helper.validate_numpy_array(s11, "s11", "complex128")
+        s11_ctype = _get_ctypes_pointer_for_buffer(
+            value=s11, library_type=_custom_types.ComplexDouble
+        )
+        array_size_ctype = ctypes.c_int32(len(s11) if s11 is not None else 0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterSetS11(
+            vi_ctype, selector_string_ctype, s11_ctype, array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s12(self, selector_string, s12):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s12."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        _helper.validate_numpy_array(s12, "s12", "complex128")
+        s12_ctype = _get_ctypes_pointer_for_buffer(
+            value=s12, library_type=_custom_types.ComplexDouble
+        )
+        array_size_ctype = ctypes.c_int32(len(s12) if s12 is not None else 0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterSetS12(
+            vi_ctype, selector_string_ctype, s12_ctype, array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s21(self, selector_string, s21):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s21."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        _helper.validate_numpy_array(s21, "s21", "complex128")
+        s21_ctype = _get_ctypes_pointer_for_buffer(
+            value=s21, library_type=_custom_types.ComplexDouble
+        )
+        array_size_ctype = ctypes.c_int32(len(s21) if s21 is not None else 0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterSetS21(
+            vi_ctype, selector_string_ctype, s21_ctype, array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s22(self, selector_string, s22):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s22."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        _helper.validate_numpy_array(s22, "s22", "complex128")
+        s22_ctype = _get_ctypes_pointer_for_buffer(
+            value=s22, library_type=_custom_types.ComplexDouble
+        )
+        array_size_ctype = ctypes.c_int32(len(s22) if s22 is not None else 0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterSetS22(
+            vi_ctype, selector_string_ctype, s22_ctype, array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_from_file(
+        self, selector_string, file_name
+    ):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_from_file."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        file_name_ctype = ctypes.create_string_buffer(file_name.encode(self._encoding))
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterSetFromFile(
+                vi_ctype, selector_string_ctype, file_name_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_number_of_markers(self, selector_string, number_of_markers):
+        """marker_configure_number_of_markers."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        number_of_markers_ctype = ctypes.c_int32(number_of_markers)
+        error_code = self._library.RFmxVNA_MarkerCfgNumberOfMarkers(
+            vi_ctype, selector_string_ctype, number_of_markers_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_type(self, selector_string, marker_type):
+        """marker_configure_type."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        marker_type_ctype = ctypes.c_int32(marker_type)
+        error_code = self._library.RFmxVNA_MarkerCfgType(
+            vi_ctype, selector_string_ctype, marker_type_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_reference_marker(self, selector_string, reference_marker):
+        """marker_configure_reference_marker."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        reference_marker_ctype = ctypes.c_int32(reference_marker)
+        error_code = self._library.RFmxVNA_MarkerCfgReferenceMarker(
+            vi_ctype, selector_string_ctype, reference_marker_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_x(self, selector_string, marker_x):
+        """marker_configure_x."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        marker_x_ctype = ctypes.c_double(marker_x)
+        error_code = self._library.RFmxVNA_MarkerCfgX(
+            vi_ctype, selector_string_ctype, marker_x_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_y(self, selector_string, marker_y1, marker_y2):
+        """marker_configure_y."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        marker_y1_ctype = ctypes.c_double(marker_y1)
+        marker_y2_ctype = ctypes.c_double(marker_y2)
+        error_code = self._library.RFmxVNA_MarkerCfgY(
+            vi_ctype, selector_string_ctype, marker_y1_ctype, marker_y2_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_data_source(self, selector_string, data_source):
+        """marker_configure_data_source."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        data_source_ctype = ctypes.create_string_buffer(data_source.encode(self._encoding))
+        error_code = self._library.RFmxVNA_MarkerCfgDataSource(
+            vi_ctype, selector_string_ctype, data_source_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_peak_search_threshold(self, selector_string, threshold_enabled, threshold):
+        """marker_configure_peak_search_threshold."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        threshold_enabled_ctype = ctypes.c_int32(threshold_enabled)
+        threshold_ctype = ctypes.c_double(threshold)
+        error_code = self._library.RFmxVNA_MarkerCfgPeakSearchThreshold(
+            vi_ctype, selector_string_ctype, threshold_enabled_ctype, threshold_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_peak_search_excursion(
+        self, selector_string, peak_excursion_enabled, peak_excursion
+    ):
+        """marker_configure_peak_search_excursion."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        peak_excursion_enabled_ctype = ctypes.c_int32(peak_excursion_enabled)
+        peak_excursion_ctype = ctypes.c_double(peak_excursion)
+        error_code = self._library.RFmxVNA_MarkerCfgPeakSearchExcursion(
+            vi_ctype, selector_string_ctype, peak_excursion_enabled_ctype, peak_excursion_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_mode(self, selector_string, marker_mode):
+        """marker_configure_mode."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        marker_mode_ctype = ctypes.c_int32(marker_mode)
+        error_code = self._library.RFmxVNA_MarkerCfgMode(
+            vi_ctype, selector_string_ctype, marker_mode_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_configure_target_value(self, selector_string, target_value):
+        """marker_configure_target_value."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        target_value_ctype = ctypes.c_double(target_value)
+        error_code = self._library.RFmxVNA_MarkerCfgTargetValue(
+            vi_ctype, selector_string_ctype, target_value_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_marker_search(self, selector_string, search_mode):
+        """marker_marker_search."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        search_mode_ctype = ctypes.c_int32(search_mode)
+        error_code = self._library.RFmxVNA_MarkerSearch(
+            vi_ctype, selector_string_ctype, search_mode_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def marker_fetch_x(self, selector_string):
+        """marker_fetch_x."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        marker_x_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_MarkerFetchX(
+            vi_ctype, selector_string_ctype, marker_x_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return marker_x_ctype.value, error_code
+
+    def marker_fetch_y(self, selector_string):
+        """marker_fetch_y."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        marker_y1_ctype = ctypes.c_double()
+        marker_y2_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_MarkerFetchY(
+            vi_ctype, selector_string_ctype, marker_y1_ctype, marker_y2_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return marker_y1_ctype.value, marker_y2_ctype.value, error_code
+
+    def calkit_manager_calkit_get_trl_reference_plane(self, selector_string):
+        """calkit_manager_calkit_get_trl_reference_plane."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        reference_plane_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitGetTRLReferencePlane(
+            vi_ctype, selector_string_ctype, reference_plane_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return enums.CalkitManagerCalkitTrlReferencePlane(reference_plane_ctype.value), error_code
+
+    def calkit_manager_calkit_get_lrl_line_auto_char(self, selector_string):
+        """calkit_manager_calkit_get_lrl_line_auto_char."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        auto_characterization_enabled_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitGetLRLLineAutoChar(
+            vi_ctype, selector_string_ctype, auto_characterization_enabled_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return bool(auto_characterization_enabled_ctype.value), error_code
+
+    def calkit_manager_calkit_connector_get_gender(self, selector_string):
+        """calkit_manager_calkit_connector_get_gender."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        connector_gender_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorGetGender(
+            vi_ctype, selector_string_ctype, connector_gender_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return enums.CalkitManagerCalkitConnectorGender(connector_gender_ctype.value), error_code
+
+    def calkit_manager_calkit_connector_get_impedance(self, selector_string):
+        """calkit_manager_calkit_connector_get_impedance."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        impedance_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorGetImpedance(
+            vi_ctype, selector_string_ctype, impedance_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return impedance_ctype.value, error_code
+
+    def calkit_manager_calkit_connector_get_minimum_frequency(self, selector_string):
+        """calkit_manager_calkit_connector_get_minimum_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        minimum_frequency_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorGetMinimumFrequency(
+            vi_ctype, selector_string_ctype, minimum_frequency_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return minimum_frequency_ctype.value, error_code
+
+    def calkit_manager_calkit_connector_get_maximum_frequency(self, selector_string):
+        """calkit_manager_calkit_connector_get_maximum_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        maximum_frequency_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorGetMaximumFrequency(
+            vi_ctype, selector_string_ctype, maximum_frequency_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return maximum_frequency_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_get_s_parameter_definition(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_s_parameter_definition."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        s_parameter_definition_ctype = ctypes.c_int32()
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementGetSParameterDefinition(
+                vi_ctype, selector_string_ctype, s_parameter_definition_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return (
+            enums.CalkitManagerCalkitCalibrationElementSParameterDefinition(
+                s_parameter_definition_ctype.value
+            ),
+            error_code,
+        )
+
+    def calkit_manager_calkit_calibration_element_get_minimum_frequency(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_minimum_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        minimum_frequency_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementGetMinimumFrequency(
+            vi_ctype, selector_string_ctype, minimum_frequency_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return minimum_frequency_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_get_maximum_frequency(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_maximum_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        maximum_frequency_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementGetMaximumFrequency(
+            vi_ctype, selector_string_ctype, maximum_frequency_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return maximum_frequency_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_model_type(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_model_type."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        model_type_ctype = ctypes.c_int32()
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetModelType(
+                vi_ctype, selector_string_ctype, model_type_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return (
+            enums.CalkitManagerCalkitCalibrationElementReflectModelType(model_type_ctype.value),
+            error_code,
+        )
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_s_param_availability(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_s_param_availability."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        s_parameter_availability_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetSParamAvailability(
+            vi_ctype, selector_string_ctype, s_parameter_availability_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return (
+            enums.CalkitManagerCalkitCalibrationElementReflectModelSParameterAvailability(
+                s_parameter_availability_ctype.value
+            ),
+            error_code,
+        )
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_c0(self, selector_string):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_c0."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        c0_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetC0(
+            vi_ctype, selector_string_ctype, c0_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return c0_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_c1(self, selector_string):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_c1."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        c1_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetC1(
+            vi_ctype, selector_string_ctype, c1_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return c1_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_c2(self, selector_string):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_c2."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        c2_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetC2(
+            vi_ctype, selector_string_ctype, c2_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return c2_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_c3(self, selector_string):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_c3."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        c3_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetC3(
+            vi_ctype, selector_string_ctype, c3_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return c3_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_offset_delay(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_offset_delay."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        offset_delay_ctype = ctypes.c_double()
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetOffsetDelay(
+                vi_ctype, selector_string_ctype, offset_delay_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return offset_delay_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_offset_loss(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_offset_loss."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        offset_loss_ctype = ctypes.c_double()
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetOffsetLoss(
+                vi_ctype, selector_string_ctype, offset_loss_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return offset_loss_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_offset_z0(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_offset_z0."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        offset_z0_ctype = ctypes.c_double()
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetOffsetZ0(
+                vi_ctype, selector_string_ctype, offset_z0_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return offset_z0_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_reference_impedance(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_reference_impedance."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        reference_impedance_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementReflectModelGetReferenceImpedance(
+            vi_ctype, selector_string_ctype, reference_impedance_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return reference_impedance_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_delay_model_get_delay(self, selector_string):
+        """calkit_manager_calkit_calibration_element_delay_model_get_delay."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        delay_ctype = ctypes.c_double()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementDelayModelGetDelay(
+            vi_ctype, selector_string_ctype, delay_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return delay_ctype.value, error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s_param_availability(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s_param_availability."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        s_parameter_availability_ctype = ctypes.c_int32()
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetSParamAvailability(
+            vi_ctype, selector_string_ctype, s_parameter_availability_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return (
+            enums.CalkitManagerCalkitCalibrationElementSParameterAvailability(
+                s_parameter_availability_ctype.value
+            ),
+            error_code,
+        )
+
+    def s_params_fetch_x_data(self, selector_string, timeout):
+        """s_params_fetch_x_data."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        timeout_ctype = ctypes.c_double(timeout)
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_SParamsFetchXData(
+            vi_ctype, selector_string_ctype, timeout_ctype, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        x_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_double, size=actual_array_size_ctype.value
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_SParamsFetchXData(
+            vi_ctype, selector_string_ctype, timeout_ctype, x_ctype, actual_array_size_ctype, None
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return x_ctype[:], error_code
+
+    def s_params_fetch_y_data(self, selector_string, timeout):
+        """s_params_fetch_y_data."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        timeout_ctype = ctypes.c_double(timeout)
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_SParamsFetchYData(
+            vi_ctype, selector_string_ctype, timeout_ctype, None, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        y1_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_float, size=actual_array_size_ctype.value
+        )
+        y2_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_float, size=actual_array_size_ctype.value
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_SParamsFetchYData(
+            vi_ctype,
+            selector_string_ctype,
+            timeout_ctype,
+            y1_ctype,
+            y2_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return y1_ctype[:], y2_ctype[:], error_code
+
+    def waves_fetch_x_data(self, selector_string, timeout):
+        """waves_fetch_x_data."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        timeout_ctype = ctypes.c_double(timeout)
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_WavesFetchXData(
+            vi_ctype, selector_string_ctype, timeout_ctype, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        x_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_double, size=actual_array_size_ctype.value
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_WavesFetchXData(
+            vi_ctype, selector_string_ctype, timeout_ctype, x_ctype, actual_array_size_ctype, None
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return x_ctype[:], error_code
+
+    def waves_fetch_y_data(self, selector_string, timeout):
+        """waves_fetch_y_data."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        timeout_ctype = ctypes.c_double(timeout)
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_WavesFetchYData(
+            vi_ctype, selector_string_ctype, timeout_ctype, None, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        y1_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_float, size=actual_array_size_ctype.value
+        )
+        y2_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_float, size=actual_array_size_ctype.value
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_WavesFetchYData(
+            vi_ctype,
+            selector_string_ctype,
+            timeout_ctype,
+            y1_ctype,
+            y2_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return y1_ctype[:], y2_ctype[:], error_code
+
+    def iq_fetch_data(self, selector_string, timeout, data):
+        """iq_fetch_data."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        timeout_ctype = ctypes.c_double(timeout)
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_IQFetchData(
+            vi_ctype,
+            selector_string_ctype,
+            timeout_ctype,
+            None,
+            None,
+            None,
+            0,
+            actual_array_size_ctype,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        x0_ctype = ctypes.c_double()
+        dx_ctype = ctypes.c_double()
+        _helper.validate_numpy_array(data, "data", "complex64")
+        if len(data) != actual_array_size_ctype.value:
+            data.resize((actual_array_size_ctype.value,), refcheck=False)
+        data_ctype = _get_ctypes_pointer_for_buffer(
+            value=data, library_type=_custom_types.ComplexSingle
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_IQFetchData(
+            vi_ctype,
+            selector_string_ctype,
+            timeout_ctype,
+            x0_ctype,
+            dx_ctype,
+            data_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return x0_ctype.value, dx_ctype.value, error_code
+
+    def calset_get_frequency_grid(self, selector_string, calset_name, error_term_identifier):
+        """calset_get_frequency_grid."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calset_name_ctype = ctypes.create_string_buffer(calset_name.encode(self._encoding))
+        error_term_identifier_ctype = ctypes.c_int32(error_term_identifier)
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_CalsetGetFrequencyGrid(
+            vi_ctype,
+            selector_string_ctype,
+            calset_name_ctype,
+            error_term_identifier_ctype,
+            None,
+            0,
+            actual_array_size_ctype,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        frequency_grid_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_double, size=actual_array_size_ctype.value
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_CalsetGetFrequencyGrid(
+            vi_ctype,
+            selector_string_ctype,
+            calset_name_ctype,
+            error_term_identifier_ctype,
+            frequency_grid_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return frequency_grid_ctype[:], error_code
+
+    def calset_get_error_term(
+        self,
+        selector_string,
+        calset_name,
+        error_term_identifier,
+        measurement_port,
+        source_port,
+        error_term,
+    ):
+        """calset_get_error_term."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calset_name_ctype = ctypes.create_string_buffer(calset_name.encode(self._encoding))
+        error_term_identifier_ctype = ctypes.c_int32(error_term_identifier)
+        measurement_port_ctype = ctypes.create_string_buffer(
+            measurement_port.encode(self._encoding)
+        )
+        source_port_ctype = ctypes.create_string_buffer(source_port.encode(self._encoding))
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_CalsetGetErrorTerm(
+            vi_ctype,
+            selector_string_ctype,
+            calset_name_ctype,
+            error_term_identifier_ctype,
+            measurement_port_ctype,
+            source_port_ctype,
+            None,
+            0,
+            actual_array_size_ctype,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        _helper.validate_numpy_array(error_term, "error_term", "complex64")
+        if len(error_term) != actual_array_size_ctype.value:
+            error_term.resize((actual_array_size_ctype.value,), refcheck=False)
+        error_term_ctype = _get_ctypes_pointer_for_buffer(
+            value=error_term, library_type=_custom_types.ComplexSingle
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_CalsetGetErrorTerm(
+            vi_ctype,
+            selector_string_ctype,
+            calset_name_ctype,
+            error_term_identifier_ctype,
+            measurement_port_ctype,
+            source_port_ctype,
+            error_term_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_measurement_memory_x_data(self, selector_string):
+        """get_measurement_memory_x_data."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_GetMeasurementMemoryXData(
+            vi_ctype, selector_string_ctype, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        measurement_memory_x_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_double, size=actual_array_size_ctype.value
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_GetMeasurementMemoryXData(
+            vi_ctype,
+            selector_string_ctype,
+            measurement_memory_x_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return measurement_memory_x_ctype[:], error_code
+
+    def get_measurement_memory_y_data(self, selector_string):
+        """get_measurement_memory_y_data."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_GetMeasurementMemoryYData(
+            vi_ctype, selector_string_ctype, None, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        measurement_memory_y1_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_float, size=actual_array_size_ctype.value
+        )
+        measurement_memory_y2_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_float, size=actual_array_size_ctype.value
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_GetMeasurementMemoryYData(
+            vi_ctype,
+            selector_string_ctype,
+            measurement_memory_y1_ctype,
+            measurement_memory_y2_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return measurement_memory_y1_ctype[:], measurement_memory_y2_ctype[:], error_code
+
+    def calkit_manager_calkit_calibration_element_get_types(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_types."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementGetTypes(
+            vi_ctype, selector_string_ctype, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        calibration_element_types_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_int32, size=actual_array_size_ctype.value
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementGetTypes(
+            vi_ctype,
+            selector_string_ctype,
+            calibration_element_types_ctype,
+            actual_array_size_ctype,
+            None,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return [
+            enums.CalkitManagerCalkitCalibrationElementType(value)
+            for value in calibration_element_types_ctype
+        ], error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_frequency(self, selector_string):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_frequency."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetFrequency(
+                vi_ctype, selector_string_ctype, None, 0, actual_array_size_ctype
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        frequency_ctype = _get_ctypes_pointer_for_buffer(
+            library_type=ctypes.c_double, size=actual_array_size_ctype.value
+        )
+
+        # call library function again to get array
+        error_code = (
+            self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetFrequency(
+                vi_ctype, selector_string_ctype, frequency_ctype, actual_array_size_ctype, None
+            )
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return frequency_ctype[:], error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s11(self, selector_string, s11):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s11."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetS11(
+            vi_ctype, selector_string_ctype, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        _helper.validate_numpy_array(s11, "s11", "complex128")
+        if len(s11) != actual_array_size_ctype.value:
+            s11.resize((actual_array_size_ctype.value,), refcheck=False)
+        s11_ctype = _get_ctypes_pointer_for_buffer(
+            value=s11, library_type=_custom_types.ComplexDouble
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetS11(
+            vi_ctype, selector_string_ctype, s11_ctype, actual_array_size_ctype, None
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s12(self, selector_string, s12):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s12."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetS12(
+            vi_ctype, selector_string_ctype, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        _helper.validate_numpy_array(s12, "s12", "complex128")
+        if len(s12) != actual_array_size_ctype.value:
+            s12.resize((actual_array_size_ctype.value,), refcheck=False)
+        s12_ctype = _get_ctypes_pointer_for_buffer(
+            value=s12, library_type=_custom_types.ComplexDouble
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetS12(
+            vi_ctype, selector_string_ctype, s12_ctype, actual_array_size_ctype, None
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s21(self, selector_string, s21):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s21."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetS21(
+            vi_ctype, selector_string_ctype, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        _helper.validate_numpy_array(s21, "s21", "complex128")
+        if len(s21) != actual_array_size_ctype.value:
+            s21.resize((actual_array_size_ctype.value,), refcheck=False)
+        s21_ctype = _get_ctypes_pointer_for_buffer(
+            value=s21, library_type=_custom_types.ComplexDouble
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetS21(
+            vi_ctype, selector_string_ctype, s21_ctype, actual_array_size_ctype, None
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s22(self, selector_string, s22):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s22."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        actual_array_size_ctype = ctypes.c_int32(0)
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetS22(
+            vi_ctype, selector_string_ctype, None, 0, actual_array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        _helper.validate_numpy_array(s22, "s22", "complex128")
+        if len(s22) != actual_array_size_ctype.value:
+            s22.resize((actual_array_size_ctype.value,), refcheck=False)
+        s22_ctype = _get_ctypes_pointer_for_buffer(
+            value=s22, library_type=_custom_types.ComplexDouble
+        )
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSParameterGetS22(
+            vi_ctype, selector_string_ctype, s22_ctype, actual_array_size_ctype, None
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def clone_signal_configuration(self, old_signal_name, new_signal_name):
+        """clone_signal_configuration."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        old_signal_name_ctype = ctypes.create_string_buffer(old_signal_name.encode(self._encoding))
+        new_signal_name_ctype = ctypes.create_string_buffer(new_signal_name.encode(self._encoding))
+        error_code = self._library.RFmxVNA_CloneSignalConfiguration(
+            vi_ctype, old_signal_name_ctype, new_signal_name_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        import nirfmxvna
+
+        signal_configuration = (
+            nirfmxvna._VnaSignalConfiguration.get_vna_signal_configuration(  # type: ignore
+                self._instr_session, new_signal_name, True
+            )
+        )
+        return signal_configuration, error_code
+
+    def delete_signal_configuration(self, ignore_driver_error):
+        """delete_signal_configuration."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        signal_name_ctype = ctypes.create_string_buffer(
+            self._signal_obj.signal_configuration_name.encode(self._encoding)
+        )
+        error_code = self._library.RFmxVNA_DeleteSignalConfiguration(vi_ctype, signal_name_ctype)
+        if not ignore_driver_error:
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def send_software_edge_trigger(self):
+        """send_software_edge_trigger."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        error_code = self._library.RFmxVNA_SendSoftwareEdgeTrigger(vi_ctype)
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_all_named_result_names(self, selector_string):
+        """get_all_named_result_names."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        actual_result_names_size_ctype = ctypes.c_int32(0)
+        default_result_exists_ctype = ctypes.c_int32()
+
+        # call library function to get the size of array
+        error_code = self._library.RFmxVNA_GetAllNamedResultNames(
+            vi_ctype,
+            selector_string_ctype,
+            None,
+            0,
+            actual_result_names_size_ctype,
+            default_result_exists_ctype,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        result_names_ctype = (ctypes.c_char * actual_result_names_size_ctype.value)()
+
+        # call library function again to get array
+        error_code = self._library.RFmxVNA_GetAllNamedResultNames(
+            vi_ctype,
+            selector_string_ctype,
+            result_names_ctype,
+            actual_result_names_size_ctype,
+            None,
+            default_result_exists_ctype,
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+
+        return (
+            _helper.split_string_by_comma(result_names_ctype.value.decode(self._encoding)),
+            default_result_exists_ctype.value,
+            error_code,
+        )
+
+    def calkit_manager_calkit_get_description(self, selector_string):
+        """calkit_manager_calkit_get_description."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calkit_description_ctype = ctypes.create_string_buffer(0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitGetDescription(
+            vi_ctype, selector_string_ctype, 0, None
+        )
+        if error_code > 0:
+            calkit_description_ctype = ctypes.create_string_buffer(error_code)
+            error_code = self._library.RFmxVNA_CalkitManagerCalkitGetDescription(
+                vi_ctype, selector_string_ctype, error_code, calkit_description_ctype
+            )
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return calkit_description_ctype.value.decode(self._encoding), error_code
+
+    def calkit_manager_calkit_get_version(self, selector_string):
+        """calkit_manager_calkit_get_version."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        calkit_version_ctype = ctypes.create_string_buffer(0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitGetVersion(
+            vi_ctype, selector_string_ctype, 0, None
+        )
+        if error_code > 0:
+            calkit_version_ctype = ctypes.create_string_buffer(error_code)
+            error_code = self._library.RFmxVNA_CalkitManagerCalkitGetVersion(
+                vi_ctype, selector_string_ctype, error_code, calkit_version_ctype
+            )
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return calkit_version_ctype.value.decode(self._encoding), error_code
+
+    def calkit_manager_calkit_connector_get_description(self, selector_string):
+        """calkit_manager_calkit_connector_get_description."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        description_ctype = ctypes.create_string_buffer(0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorGetDescription(
+            vi_ctype, selector_string_ctype, 0, None
+        )
+        if error_code > 0:
+            description_ctype = ctypes.create_string_buffer(error_code)
+            error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorGetDescription(
+                vi_ctype, selector_string_ctype, error_code, description_ctype
+            )
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return description_ctype.value.decode(self._encoding), error_code
+
+    def calkit_manager_calkit_connector_get_type(self, selector_string):
+        """calkit_manager_calkit_connector_get_type."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        connector_type_ctype = ctypes.create_string_buffer(0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorGetType(
+            vi_ctype, selector_string_ctype, 0, None
+        )
+        if error_code > 0:
+            connector_type_ctype = ctypes.create_string_buffer(error_code)
+            error_code = self._library.RFmxVNA_CalkitManagerCalkitConnectorGetType(
+                vi_ctype, selector_string_ctype, error_code, connector_type_ctype
+            )
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return connector_type_ctype.value.decode(self._encoding), error_code
+
+    def calkit_manager_calkit_calibration_element_get_description(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_description."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        description_ctype = ctypes.create_string_buffer(0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementGetDescription(
+            vi_ctype, selector_string_ctype, 0, None
+        )
+        if error_code > 0:
+            description_ctype = ctypes.create_string_buffer(error_code)
+            error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementGetDescription(
+                vi_ctype, selector_string_ctype, error_code, description_ctype
+            )
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return description_ctype.value.decode(self._encoding), error_code
+
+    def calkit_manager_calkit_calibration_element_set_port_connectors(
+        self, selector_string, connector_ids
+    ):
+        """calkit_manager_calkit_calibration_element_set_port_connectors."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        connector_ids_ctype = ctypes.create_string_buffer(connector_ids.encode(self._encoding))
+        array_size_ctype = ctypes.c_int32(len(connector_ids) if connector_ids is not None else 0)
+        error_code = self._library.RFmxVNA_CalkitManagerCalkitCalibrationElementSetPortConnectors(
+            vi_ctype, selector_string_ctype, connector_ids_ctype, array_size_ctype
+        )
+        errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return error_code
+
+    def get_s_parameter(self, selector_string):
+        """get_s_parameter."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        s_parameter_ctype = ctypes.create_string_buffer(0)
+        error_code = self._library.RFmxVNA_SParamsGetSParameter(
+            vi_ctype, selector_string_ctype, 0, None
+        )
+        if error_code > 0:
+            s_parameter_ctype = ctypes.create_string_buffer(error_code)
+            error_code = self._library.RFmxVNA_SParamsGetSParameter(
+                vi_ctype, selector_string_ctype, error_code, s_parameter_ctype
+            )
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return s_parameter_ctype.value.decode(self._encoding), error_code
+
+    def get_wave(self, selector_string):
+        """get_wave."""
+        vi_ctype = ctypes.c_uint32(self._vi)
+        selector_string_ctype = ctypes.create_string_buffer(selector_string.encode(self._encoding))
+        wave_ctype = ctypes.create_string_buffer(0)
+        error_code = self._library.RFmxVNA_WavesGetWave(vi_ctype, selector_string_ctype, 0, None)
+        if error_code > 0:
+            wave_ctype = ctypes.create_string_buffer(error_code)
+            error_code = self._library.RFmxVNA_WavesGetWave(
+                vi_ctype, selector_string_ctype, error_code, wave_ctype
+            )
+            errors.handle_error(self, error_code, ignore_warnings=True, is_error_handling=False)
+        return wave_ctype.value.decode(self._encoding), error_code