# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_OpenIPMI')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_OpenIPMI')
    _OpenIPMI = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_OpenIPMI', [dirname(__file__)])
        except ImportError:
            import _OpenIPMI
            return _OpenIPMI
        try:
            _mod = imp.load_module('_OpenIPMI', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _OpenIPMI = swig_import_helper()
    del swig_import_helper
else:
    import _OpenIPMI
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

class strconstarray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, strconstarray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, strconstarray, name)
    __repr__ = _swig_repr
    __swig_setmethods__["val"] = _OpenIPMI.strconstarray_val_set
    __swig_getmethods__["val"] = _OpenIPMI.strconstarray_val_get
    if _newclass:
        val = _swig_property(_OpenIPMI.strconstarray_val_get, _OpenIPMI.strconstarray_val_set)
    __swig_setmethods__["len"] = _OpenIPMI.strconstarray_len_set
    __swig_getmethods__["len"] = _OpenIPMI.strconstarray_len_get
    if _newclass:
        len = _swig_property(_OpenIPMI.strconstarray_len_get, _OpenIPMI.strconstarray_len_set)

    def __init__(self):
        this = _OpenIPMI.new_strconstarray()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _OpenIPMI.delete_strconstarray
    __del__ = lambda self: None
strconstarray_swigregister = _OpenIPMI.strconstarray_swigregister
strconstarray_swigregister(strconstarray)

class argarray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, argarray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, argarray, name)
    __repr__ = _swig_repr
    __swig_setmethods__["val"] = _OpenIPMI.argarray_val_set
    __swig_getmethods__["val"] = _OpenIPMI.argarray_val_get
    if _newclass:
        val = _swig_property(_OpenIPMI.argarray_val_get, _OpenIPMI.argarray_val_set)
    __swig_setmethods__["len"] = _OpenIPMI.argarray_len_set
    __swig_getmethods__["len"] = _OpenIPMI.argarray_len_get
    if _newclass:
        len = _swig_property(_OpenIPMI.argarray_len_get, _OpenIPMI.argarray_len_set)

    def __init__(self):
        this = _OpenIPMI.new_argarray()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _OpenIPMI.delete_argarray
    __del__ = lambda self: None
argarray_swigregister = _OpenIPMI.argarray_swigregister
argarray_swigregister(argarray)

class iargarray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, iargarray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, iargarray, name)
    __repr__ = _swig_repr
    __swig_setmethods__["val"] = _OpenIPMI.iargarray_val_set
    __swig_getmethods__["val"] = _OpenIPMI.iargarray_val_get
    if _newclass:
        val = _swig_property(_OpenIPMI.iargarray_val_get, _OpenIPMI.iargarray_val_set)
    __swig_setmethods__["len"] = _OpenIPMI.iargarray_len_set
    __swig_getmethods__["len"] = _OpenIPMI.iargarray_len_get
    if _newclass:
        len = _swig_property(_OpenIPMI.iargarray_len_get, _OpenIPMI.iargarray_len_set)

    def __init__(self):
        this = _OpenIPMI.new_iargarray()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _OpenIPMI.delete_iargarray
    __del__ = lambda self: None
iargarray_swigregister = _OpenIPMI.iargarray_swigregister
iargarray_swigregister(iargarray)

class ipmi_domain_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_domain_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_domain_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def get_name(self) -> "char *":
        return _OpenIPMI.ipmi_domain_t_get_name(self)

    def get_id(self) -> "ipmi_domain_id_t *":
        return _OpenIPMI.ipmi_domain_t_get_id(self)

    def get_guid(self) -> "char *":
        return _OpenIPMI.ipmi_domain_t_get_guid(self)

    def close(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_close(self, handler)

    def add_connect_change_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_add_connect_change_handler(self, handler)

    def remove_connect_change_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_remove_connect_change_handler(self, handler)

    def iterate_connections(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_iterate_connections(self, handler)

    def activate_connection(self, connection: 'int') -> "int":
        return _OpenIPMI.ipmi_domain_t_activate_connection(self, connection)

    def is_connection_active(self, connection: 'int', active: 'unsigned int *') -> "int":
        return _OpenIPMI.ipmi_domain_t_is_connection_active(self, connection, active)

    def is_connection_up(self, connection: 'int', up: 'unsigned int *') -> "int":
        return _OpenIPMI.ipmi_domain_t_is_connection_up(self, connection, up)

    def num_connection_ports(self, connection: 'int', ports: 'unsigned int *') -> "int":
        return _OpenIPMI.ipmi_domain_t_num_connection_ports(self, connection, ports)

    def is_connection_port_up(self, connection: 'int', port: 'int', up: 'unsigned int *') -> "int":
        return _OpenIPMI.ipmi_domain_t_is_connection_port_up(self, connection, port, up)

    def get_port_info(self, connection: 'int', port: 'int') -> "char *":
        return _OpenIPMI.ipmi_domain_t_get_port_info(self, connection, port)

    def get_connection_args(self, connection: 'int') -> "ipmi_args_t *":
        return _OpenIPMI.ipmi_domain_t_get_connection_args(self, connection)

    def get_connection_type(self, connection: 'int') -> "char *":
        return _OpenIPMI.ipmi_domain_t_get_connection_type(self, connection)

    def add_entity_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_add_entity_update_handler(self, handler)

    def remove_entity_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_remove_entity_update_handler(self, handler)

    def iterate_entities(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_iterate_entities(self, handler)

    def add_mc_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_add_mc_update_handler(self, handler)

    def remove_mc_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_remove_mc_update_handler(self, handler)

    def iterate_mcs(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_iterate_mcs(self, handler)

    def get_type(self) -> "char const *":
        return _OpenIPMI.ipmi_domain_t_get_type(self)

    def start_ipmb_mc_scan(self, channel: 'int', start_addr: 'int', end_addr: 'int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_domain_t_start_ipmb_mc_scan(self, channel, start_addr, end_addr, handler)

    def start_full_ipmb_scan(self) -> "void":
        return _OpenIPMI.ipmi_domain_t_start_full_ipmb_scan(self)

    def send_command_addr(self, addr: 'char *', lun: 'int', netfn: 'int', cmd: 'int', msg_data: 'intarray', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_domain_t_send_command_addr(self, addr, lun, netfn, cmd, msg_data, handler)

    def detect_presence_changes(self, force: 'int'=0) -> "int":
        return _OpenIPMI.ipmi_domain_t_detect_presence_changes(self, force)

    def set_sel_rescan_time(self, seconds: 'int') -> "void":
        return _OpenIPMI.ipmi_domain_t_set_sel_rescan_time(self, seconds)

    def get_sel_rescan_time(self) -> "int":
        return _OpenIPMI.ipmi_domain_t_get_sel_rescan_time(self)

    def set_ipmb_rescan_time(self, seconds: 'int') -> "void":
        return _OpenIPMI.ipmi_domain_t_set_ipmb_rescan_time(self, seconds)

    def get_ipmb_rescan_time(self) -> "int":
        return _OpenIPMI.ipmi_domain_t_get_ipmb_rescan_time(self)

    def add_event_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_add_event_handler(self, handler)

    def remove_event_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_t_remove_event_handler(self, handler)

    def first_event(self) -> "ipmi_event_t *":
        return _OpenIPMI.ipmi_domain_t_first_event(self)

    def last_event(self) -> "ipmi_event_t *":
        return _OpenIPMI.ipmi_domain_t_last_event(self)

    def next_event(self, event: 'ipmi_event_t') -> "ipmi_event_t *":
        return _OpenIPMI.ipmi_domain_t_next_event(self, event)

    def prev_event(self, event: 'ipmi_event_t') -> "ipmi_event_t *":
        return _OpenIPMI.ipmi_domain_t_prev_event(self, event)

    def sel_count(self) -> "int":
        return _OpenIPMI.ipmi_domain_t_sel_count(self)

    def sel_entries_used(self) -> "int":
        return _OpenIPMI.ipmi_domain_t_sel_entries_used(self)

    def reread_sels(self, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_domain_t_reread_sels(self, handler)

    def fru_alloc(self, is_logical: 'int', device_address: 'int', device_id: 'int', lun: 'int', private_bus: 'int', channel: 'int', handler: 'swig_cb *'=None) -> "ipmi_fru_t *":
        return _OpenIPMI.ipmi_domain_t_fru_alloc(self, is_logical, device_address, device_id, lun, private_bus, channel, handler)

    def get_pet(self, connection: 'int', channel: 'int', ip_addr: 'char *', mac_addr: 'char *', eft_sel: 'int', policy_num: 'int', apt_sel: 'int', lan_dest_sel: 'int', handler: 'swig_cb *'=None) -> "ipmi_pet_t *":
        return _OpenIPMI.ipmi_domain_t_get_pet(self, connection, channel, ip_addr, mac_addr, eft_sel, policy_num, apt_sel, lan_dest_sel, handler)

    def create_sol(self, connection: 'int', handler: 'swig_cb *') -> "ipmi_sol_conn_t *":
        return _OpenIPMI.ipmi_domain_t_create_sol(self, connection, handler)
ipmi_domain_t_swigregister = _OpenIPMI.ipmi_domain_t_swigregister
ipmi_domain_t_swigregister(ipmi_domain_t)

class ipmi_domain_id_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_domain_id_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_domain_id_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_domain_id_t
    __del__ = lambda self: None

    def cmp(self, other: 'ipmi_domain_id_t') -> "int":
        return _OpenIPMI.ipmi_domain_id_t_cmp(self, other)

    def to_domain(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_domain_id_t_to_domain(self, handler)
ipmi_domain_id_t_swigregister = _OpenIPMI.ipmi_domain_id_t_swigregister
ipmi_domain_id_t_swigregister(ipmi_domain_id_t)

class ipmi_args_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_args_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_args_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_args_t
    __del__ = lambda self: None

    def get_type(self) -> "char const *":
        return _OpenIPMI.ipmi_args_t_get_type(self)

    def get_val(self, argnum: 'int', name: 'char const **', type: 'char const **', help: 'char const **', value: 'char **', range: 'strconstarray') -> "int":
        return _OpenIPMI.ipmi_args_t_get_val(self, argnum, name, type, help, value, range)

    def set_val(self, argnum: 'int', name: 'char const *', value: 'char const *') -> "int":
        return _OpenIPMI.ipmi_args_t_set_val(self, argnum, name, value)
ipmi_args_t_swigregister = _OpenIPMI.ipmi_args_t_swigregister
ipmi_args_t_swigregister(ipmi_args_t)

class ipmi_entity_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_entity_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_entity_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def get_domain(self) -> "ipmi_domain_t *":
        return _OpenIPMI.ipmi_entity_t_get_domain(self)

    def get_name(self) -> "char *":
        return _OpenIPMI.ipmi_entity_t_get_name(self)

    def get_id(self) -> "ipmi_entity_id_t *":
        return _OpenIPMI.ipmi_entity_t_get_id(self)

    def iterate_children(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_iterate_children(self, handler)

    def iterate_parents(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_iterate_parents(self, handler)

    def iterate_sensors(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_iterate_sensors(self, handler)

    def iterate_controls(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_iterate_controls(self, handler)

    def add_presence_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_add_presence_handler(self, handler)

    def remove_presence_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_remove_presence_handler(self, handler)

    def add_sensor_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_add_sensor_update_handler(self, handler)

    def remove_sensor_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_remove_sensor_update_handler(self, handler)

    def add_control_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_add_control_update_handler(self, handler)

    def remove_control_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_remove_control_update_handler(self, handler)

    def add_fru_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_add_fru_update_handler(self, handler)

    def remove_fru_update_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_remove_fru_update_handler(self, handler)

    def add_fru_update_werr_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_add_fru_update_werr_handler(self, handler)

    def remove_fru_update_werr_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_remove_fru_update_werr_handler(self, handler)

    def get_type(self) -> "char *":
        return _OpenIPMI.ipmi_entity_t_get_type(self)

    def is_fru(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_is_fru(self)

    def get_id_string(self) -> "char *":
        return _OpenIPMI.ipmi_entity_t_get_id_string(self)

    def get_entity_id(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_entity_id(self)

    def get_entity_id_string(self) -> "char const *":
        return _OpenIPMI.ipmi_entity_t_get_entity_id_string(self)

    def get_entity_instance(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_entity_instance(self)

    def get_entity_device_channel(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_entity_device_channel(self)

    def get_entity_device_address(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_entity_device_address(self)

    def get_fru(self) -> "ipmi_fru_t *":
        return _OpenIPMI.ipmi_entity_t_get_fru(self)

    def get_presence_sensor_always_there(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_presence_sensor_always_there(self)

    def is_child(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_is_child(self)

    def is_parent(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_is_parent(self)

    def get_channel(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_channel(self)

    def get_lun(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_lun(self)

    def get_oem(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_oem(self)

    def get_access_address(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_access_address(self)

    def get_private_bus_id(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_private_bus_id(self)

    def get_device_type(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_device_type(self)

    def get_device_modifier(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_device_modifier(self)

    def get_slave_address(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_slave_address(self)

    def get_mc_id(self) -> "ipmi_mcid_t *":
        return _OpenIPMI.ipmi_entity_t_get_mc_id(self)

    def get_is_logical_fru(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_is_logical_fru(self)

    def get_fru_device_id(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_fru_device_id(self)

    def get_ACPI_system_power_notify_required(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_ACPI_system_power_notify_required(self)

    def get_ACPI_device_power_notify_required(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_ACPI_device_power_notify_required(self)

    def get_controller_logs_init_agent_errors(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_controller_logs_init_agent_errors(self)

    def get_log_init_agent_errors_accessing(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_log_init_agent_errors_accessing(self)

    def get_global_init(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_global_init(self)

    def get_chassis_device(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_chassis_device(self)

    def get_bridge(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_bridge(self)

    def get_IPMB_event_generator(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_IPMB_event_generator(self)

    def get_IPMB_event_receiver(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_IPMB_event_receiver(self)

    def get_FRU_inventory_device(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_FRU_inventory_device(self)

    def get_SEL_device(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_SEL_device(self)

    def get_SDR_repository_device(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_SDR_repository_device(self)

    def get_sensor_device(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_sensor_device(self)

    def get_address_span(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_address_span(self)

    def get_dlr_id(self) -> "char *":
        return _OpenIPMI.ipmi_entity_t_get_dlr_id(self)

    def is_present(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_is_present(self)

    def get_physical_slot_num(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_get_physical_slot_num(self)

    def is_hot_swappable(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_is_hot_swappable(self)

    def supports_managed_hot_swap(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_supports_managed_hot_swap(self)

    def add_hot_swap_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_add_hot_swap_handler(self, handler)

    def remove_hot_swap_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_remove_hot_swap_handler(self, handler)

    def get_hot_swap_state(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_get_hot_swap_state(self, handler)

    def supports_auto_activate_time(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_supports_auto_activate_time(self)

    def get_auto_activate_time(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_get_auto_activate_time(self, handler)

    def set_auto_activate_time(self, auto_act: 'ipmi_timeout_t', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_entity_t_set_auto_activate_time(self, auto_act, handler)

    def supports_auto_deactivate_time(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_supports_auto_deactivate_time(self)

    def get_auto_deactivate_time(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_t_get_auto_deactivate_time(self, handler)

    def set_auto_deactivate_time(self, auto_act: 'ipmi_timeout_t', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_entity_t_set_auto_deactivate_time(self, auto_act, handler)

    def set_activation_requested(self, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_entity_t_set_activation_requested(self, handler)

    def activate(self, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_entity_t_activate(self, handler)

    def deactivate(self, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_entity_t_deactivate(self, handler)

    def check_hot_swap_state(self) -> "int":
        return _OpenIPMI.ipmi_entity_t_check_hot_swap_state(self)
ipmi_entity_t_swigregister = _OpenIPMI.ipmi_entity_t_swigregister
ipmi_entity_t_swigregister(ipmi_entity_t)

class ipmi_entity_id_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_entity_id_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_entity_id_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_entity_id_t
    __del__ = lambda self: None

    def cmp(self, other: 'ipmi_entity_id_t') -> "int":
        return _OpenIPMI.ipmi_entity_id_t_cmp(self, other)

    def to_entity(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_entity_id_t_to_entity(self, handler)
ipmi_entity_id_t_swigregister = _OpenIPMI.ipmi_entity_id_t_swigregister
ipmi_entity_id_t_swigregister(ipmi_entity_id_t)

class ipmi_fru_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_fru_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_fru_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_fru_t
    __del__ = lambda self: None

    def get_domain_id(self) -> "ipmi_domain_id_t *":
        return _OpenIPMI.ipmi_fru_t_get_domain_id(self)

    def str_to_index(self, name: 'char *') -> "int":
        return _OpenIPMI.ipmi_fru_t_str_to_index(self, name)

    def get(self, index: 'int', num: 'int *') -> "char *":
        return _OpenIPMI.ipmi_fru_t_get(self, index, num)

    def get_num_multi_records(self) -> "int":
        return _OpenIPMI.ipmi_fru_t_get_num_multi_records(self)

    def get_multirecord(self, num: 'int') -> "char *":
        return _OpenIPMI.ipmi_fru_t_get_multirecord(self, num)

    def set(self, index: 'int', num: 'int', type: 'char *', value: 'char *'=None) -> "int":
        return _OpenIPMI.ipmi_fru_t_set(self, index, num, type, value)

    def set_array(self, index: 'int', num: 'int', type: 'char *', value: 'intarray') -> "int":
        return _OpenIPMI.ipmi_fru_t_set_array(self, index, num, type, value)

    def set_multirecord(self, num: 'unsigned int', type: 'unsigned int', version: 'unsigned int', value: 'char *'=None) -> "int":
        return _OpenIPMI.ipmi_fru_t_set_multirecord(self, num, type, version, value)

    def set_multirecord_array(self, num: 'unsigned int', type: 'unsigned int', version: 'unsigned int', value: 'intarray') -> "int":
        return _OpenIPMI.ipmi_fru_t_set_multirecord_array(self, num, type, version, value)

    def add_area(self, area: 'unsigned int', offset: 'unsigned int', length: 'unsigned int') -> "int":
        return _OpenIPMI.ipmi_fru_t_add_area(self, area, offset, length)

    def delete_area(self, area: 'int') -> "int":
        return _OpenIPMI.ipmi_fru_t_delete_area(self, area)

    def area_get_offset(self, area: 'unsigned int', offset: 'unsigned int *') -> "int":
        return _OpenIPMI.ipmi_fru_t_area_get_offset(self, area, offset)

    def area_get_length(self, area: 'unsigned int', length: 'unsigned int *') -> "int":
        return _OpenIPMI.ipmi_fru_t_area_get_length(self, area, length)

    def area_set_offset(self, area: 'unsigned int', offset: 'unsigned int') -> "int":
        return _OpenIPMI.ipmi_fru_t_area_set_offset(self, area, offset)

    def area_set_length(self, area: 'unsigned int', length: 'unsigned int') -> "int":
        return _OpenIPMI.ipmi_fru_t_area_set_length(self, area, length)

    def area_get_used_length(self, area: 'unsigned int', used_length: 'unsigned int *') -> "int":
        return _OpenIPMI.ipmi_fru_t_area_get_used_length(self, area, used_length)

    def write(self, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_fru_t_write(self, handler)

    def multi_record_get_root_node(self, record_num: 'unsigned int', name: 'char const **', sub_node: 'ipmi_fru_node_t **') -> "int":
        return _OpenIPMI.ipmi_fru_t_multi_record_get_root_node(self, record_num, name, sub_node)

    def get_root_node(self, type: 'char const **', sub_node: 'ipmi_fru_node_t **') -> "int":
        return _OpenIPMI.ipmi_fru_t_get_root_node(self, type, sub_node)
ipmi_fru_t_swigregister = _OpenIPMI.ipmi_fru_t_swigregister
ipmi_fru_t_swigregister(ipmi_fru_t)
FRU_INTERNAL_USE_AREA = _OpenIPMI.FRU_INTERNAL_USE_AREA
FRU_CHASSIS_INFO_AREA = _OpenIPMI.FRU_CHASSIS_INFO_AREA
FRU_BOARD_INFO_AREA = _OpenIPMI.FRU_BOARD_INFO_AREA
FRU_PRODUCT_INFO_AREA = _OpenIPMI.FRU_PRODUCT_INFO_AREA
FRU_MULTI_RECORD_AREA = _OpenIPMI.FRU_MULTI_RECORD_AREA

class ipmi_fru_node_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_fru_node_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_fru_node_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_fru_node_t
    __del__ = lambda self: None

    def get_field(self, index: 'unsigned int', name: 'char const **', type: 'char const **', value: 'char **', sub_node: 'ipmi_fru_node_t **') -> "int":
        return _OpenIPMI.ipmi_fru_node_t_get_field(self, index, name, type, value, sub_node)

    def get_enum_val(self, index: 'unsigned int', pos: 'int *', nextpos: 'int *', data: 'char const **') -> "int":
        return _OpenIPMI.ipmi_fru_node_t_get_enum_val(self, index, pos, nextpos, data)

    def set_field(self, index: 'unsigned int', type: 'char const *', value: 'char *') -> "int":
        return _OpenIPMI.ipmi_fru_node_t_set_field(self, index, type, value)

    def settable(self, index: 'unsigned int') -> "int":
        return _OpenIPMI.ipmi_fru_node_t_settable(self, index)

    def get_subtype(self) -> "char *":
        return _OpenIPMI.ipmi_fru_node_t_get_subtype(self)
ipmi_fru_node_t_swigregister = _OpenIPMI.ipmi_fru_node_t_swigregister
ipmi_fru_node_t_swigregister(ipmi_fru_node_t)

class ipmi_mc_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_mc_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_mc_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def get_domain(self) -> "ipmi_domain_t *":
        return _OpenIPMI.ipmi_mc_t_get_domain(self)

    def get_name(self) -> "char *":
        return _OpenIPMI.ipmi_mc_t_get_name(self)

    def get_id(self) -> "ipmi_mcid_t *":
        return _OpenIPMI.ipmi_mc_t_get_id(self)

    def get_guid(self) -> "char *":
        return _OpenIPMI.ipmi_mc_t_get_guid(self)

    def provides_device_sdrs(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_provides_device_sdrs(self)

    def device_available(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_device_available(self)

    def chassis_support(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_chassis_support(self)

    def bridge_support(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_bridge_support(self)

    def ipmb_event_generator_support(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_ipmb_event_generator_support(self)

    def ipmb_event_receiver_support(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_ipmb_event_receiver_support(self)

    def fru_inventory_support(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_fru_inventory_support(self)

    def sel_device_support(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_device_support(self)

    def sdr_repository_support(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sdr_repository_support(self)

    def sensor_device_support(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sensor_device_support(self)

    def device_id(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_device_id(self)

    def device_revision(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_device_revision(self)

    def major_fw_revision(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_major_fw_revision(self)

    def minor_fw_revision(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_minor_fw_revision(self)

    def major_version(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_major_version(self)

    def minor_version(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_minor_version(self)

    def manufacturer_id(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_manufacturer_id(self)

    def product_id(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_product_id(self)

    def aux_fw_revision(self) -> "char *":
        return _OpenIPMI.ipmi_mc_t_aux_fw_revision(self)

    def is_active(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_is_active(self)

    def add_active_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mc_t_add_active_handler(self, handler)

    def remove_active_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mc_t_remove_active_handler(self, handler)

    def add_fully_up_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mc_t_add_fully_up_handler(self, handler)

    def remove_fully_up_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mc_t_remove_fully_up_handler(self, handler)

    def send_command(self, lun: 'int', netfn: 'int', cmd: 'int', msg_data: 'intarray', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_mc_t_send_command(self, lun, netfn, cmd, msg_data, handler)

    def reset(self, reset_type: 'int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_mc_t_reset(self, reset_type, handler)

    def get_events_enable(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_get_events_enable(self)

    def set_events_enable(self, val: 'int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_mc_t_set_events_enable(self, val, handler)

    def get_event_log_enable(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mc_t_get_event_log_enable(self, handler)

    def set_event_log_enable(self, val: 'int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_mc_t_set_event_log_enable(self, val, handler)

    def reread_sensors(self, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_mc_t_reread_sensors(self, handler)

    def set_sel_rescan_time(self, seconds: 'unsigned int') -> "void":
        return _OpenIPMI.ipmi_mc_t_set_sel_rescan_time(self, seconds)

    def get_sel_rescan_time(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_get_sel_rescan_time(self)

    def reread_sel(self, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_mc_t_reread_sel(self, handler)

    def get_current_sel_time(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mc_t_get_current_sel_time(self, handler)

    def first_event(self) -> "ipmi_event_t *":
        return _OpenIPMI.ipmi_mc_t_first_event(self)

    def last_event(self) -> "ipmi_event_t *":
        return _OpenIPMI.ipmi_mc_t_last_event(self)

    def next_event(self, event: 'ipmi_event_t') -> "ipmi_event_t *":
        return _OpenIPMI.ipmi_mc_t_next_event(self, event)

    def prev_event(self, event: 'ipmi_event_t') -> "ipmi_event_t *":
        return _OpenIPMI.ipmi_mc_t_prev_event(self, event)

    def event_by_recid(self, record_id: 'int') -> "ipmi_event_t *":
        return _OpenIPMI.ipmi_mc_t_event_by_recid(self, record_id)

    def sel_count(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_count(self)

    def sel_entries_used(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_entries_used(self)

    def sel_get_major_version(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_major_version(self)

    def sel_get_minor_version(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_minor_version(self)

    def sel_get_num_entries(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_num_entries(self)

    def sel_get_free_bytes(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_free_bytes(self)

    def sel_get_overflow(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_overflow(self)

    def sel_get_supports_delete_sel(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_supports_delete_sel(self)

    def sel_get_supports_partial_add_sel(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_supports_partial_add_sel(self)

    def sel_get_supports_reserve_sel(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_supports_reserve_sel(self)

    def sel_get_supports_get_sel_allocation(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_supports_get_sel_allocation(self)

    def sel_get_last_addition_timestamp(self) -> "int":
        return _OpenIPMI.ipmi_mc_t_sel_get_last_addition_timestamp(self)

    def channel_get_info(self, channel: 'int', handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mc_t_channel_get_info(self, channel, handler)

    def channel_get_access(self, channel: 'int', type: 'char *', handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mc_t_channel_get_access(self, channel, type, handler)

    def channel_set_access(self, access: 'ipmi_channel_access_t', channel: 'int', type: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_mc_t_channel_set_access(self, access, channel, type, handler)

    def get_users(self, channel: 'int', user: 'int', handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mc_t_get_users(self, channel, user, handler)

    def set_user(self, userinfo: 'ipmi_user_t', channel: 'int', usernum: 'int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_mc_t_set_user(self, userinfo, channel, usernum, handler)

    def get_lanparm(self, channel: 'int') -> "ipmi_lanparm_t *":
        return _OpenIPMI.ipmi_mc_t_get_lanparm(self, channel)

    def get_pef(self, handler: 'swig_cb *'=None) -> "ipmi_pef_t *":
        return _OpenIPMI.ipmi_mc_t_get_pef(self, handler)

    def get_pet(self, channel: 'int', ip_addr: 'char *', mac_addr: 'char *', eft_sel: 'int', policy_num: 'int', apt_sel: 'int', lan_dest_sel: 'int', handler: 'swig_cb *'=None) -> "ipmi_pet_t *":
        return _OpenIPMI.ipmi_mc_t_get_pet(self, channel, ip_addr, mac_addr, eft_sel, policy_num, apt_sel, lan_dest_sel, handler)

    def get_solparm(self, channel: 'int') -> "ipmi_solparm_t *":
        return _OpenIPMI.ipmi_mc_t_get_solparm(self, channel)
ipmi_mc_t_swigregister = _OpenIPMI.ipmi_mc_t_swigregister
ipmi_mc_t_swigregister(ipmi_mc_t)
MC_RESET_COLD = _OpenIPMI.MC_RESET_COLD
MC_RESET_WARM = _OpenIPMI.MC_RESET_WARM
MAX_USED_CHANNELS = _OpenIPMI.MAX_USED_CHANNELS

class ipmi_mcid_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_mcid_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_mcid_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_mcid_t
    __del__ = lambda self: None

    def cmp(self, other: 'ipmi_mcid_t') -> "int":
        return _OpenIPMI.ipmi_mcid_t_cmp(self, other)

    def to_mc(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_mcid_t_to_mc(self, handler)
ipmi_mcid_t_swigregister = _OpenIPMI.ipmi_mcid_t_swigregister
ipmi_mcid_t_swigregister(ipmi_mcid_t)

class ipmi_event_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_event_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_event_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_event_t
    __del__ = lambda self: None

    def delete(self, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_event_t_delete(self, handler)

    def get_mc_id(self) -> "ipmi_mcid_t *":
        return _OpenIPMI.ipmi_event_t_get_mc_id(self)

    def get_record_id(self) -> "int":
        return _OpenIPMI.ipmi_event_t_get_record_id(self)

    def get_type(self) -> "int":
        return _OpenIPMI.ipmi_event_t_get_type(self)

    def get_timestamp(self) -> "double":
        return _OpenIPMI.ipmi_event_t_get_timestamp(self)

    def get_data(self) -> "intarray":
        return _OpenIPMI.ipmi_event_t_get_data(self)

    def call_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_event_t_call_handler(self, handler)
ipmi_event_t_swigregister = _OpenIPMI.ipmi_event_t_swigregister
ipmi_event_t_swigregister(ipmi_event_t)

class ipmi_sensor_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_sensor_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_sensor_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def get_name(self) -> "char *":
        return _OpenIPMI.ipmi_sensor_t_get_name(self)

    def get_id(self) -> "ipmi_sensor_id_t *":
        return _OpenIPMI.ipmi_sensor_t_get_id(self)

    def add_event_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_add_event_handler(self, handler)

    def remove_event_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_remove_event_handler(self, handler)

    def set_event_enables(self, states: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sensor_t_set_event_enables(self, states, handler)

    def enable_events(self, states: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sensor_t_enable_events(self, states, handler)

    def disable_events(self, states: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sensor_t_disable_events(self, states, handler)

    def get_event_enables(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_event_enables(self, handler)

    def rearm(self, global_enable: 'int', states: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sensor_t_rearm(self, global_enable, states, handler)

    def get_hysteresis(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_hysteresis(self, handler)

    def set_hysteresis(self, positive_hysteresis: 'unsigned int', negative_hysteresis: 'unsigned int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sensor_t_set_hysteresis(self, positive_hysteresis, negative_hysteresis, handler)

    def get_default_thresholds(self) -> "char *":
        return _OpenIPMI.ipmi_sensor_t_get_default_thresholds(self)

    def set_thresholds(self, thresholds: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sensor_t_set_thresholds(self, thresholds, handler)

    def get_thresholds(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_thresholds(self, handler)

    def get_value(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_value(self, handler)

    def get_lun(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_lun(self)

    def get_num(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_num(self)

    def get_sensor_type_string(self) -> "char const *":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_type_string(self)

    def get_sensor_type(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_type(self)

    def get_event_reading_type_string(self) -> "char const *":
        return _OpenIPMI.ipmi_sensor_t_get_event_reading_type_string(self)

    def get_event_reading_type(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_event_reading_type(self)

    def get_rate_unit_string(self) -> "char const *":
        return _OpenIPMI.ipmi_sensor_t_get_rate_unit_string(self)

    def get_rate_unit(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_rate_unit(self)

    def get_base_unit_string(self) -> "char const *":
        return _OpenIPMI.ipmi_sensor_t_get_base_unit_string(self)

    def get_base_unit(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_base_unit(self)

    def get_modifier_unit_string(self) -> "char const *":
        return _OpenIPMI.ipmi_sensor_t_get_modifier_unit_string(self)

    def get_modifier_unit(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_modifier_unit(self)

    def get_modifier_unit_use(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_modifier_unit_use(self)

    def get_percentage(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_percentage(self)

    def reading_name_string(self, offset: 'int') -> "char const *":
        return _OpenIPMI.ipmi_sensor_t_reading_name_string(self, offset)

    def get_entity_id(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_entity_id(self)

    def get_entity_instance(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_entity_instance(self)

    def get_entity(self) -> "ipmi_entity_t *":
        return _OpenIPMI.ipmi_sensor_t_get_entity(self)

    def get_sensor_init_scanning(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_scanning(self)

    def get_sensor_init_events(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_events(self)

    def get_sensor_init_thresholds(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_thresholds(self)

    def get_sensor_init_hysteresis(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_hysteresis(self)

    def get_sensor_init_type(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_type(self)

    def get_sensor_init_pu_events(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_pu_events(self)

    def get_sensor_init_pu_scanning(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_pu_scanning(self)

    def get_ignore_if_no_entity(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_ignore_if_no_entity(self)

    def get_supports_auto_rearm(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_supports_auto_rearm(self)

    def get_threshold_access(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_threshold_access(self)

    def get_hysteresis_support(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_hysteresis_support(self)

    def get_event_support(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_event_support(self)

    def get_sensor_direction(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_direction(self)

    def is_readable(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_is_readable(self)

    def threshold_event_supported(self, event: 'char *', val: 'int *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_threshold_event_supported(self, event, val)

    def threshold_settable(self, threshold: 'char *', val: 'int *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_threshold_settable(self, threshold, val)

    def threshold_readable(self, threshold: 'char *', val: 'int *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_threshold_readable(self, threshold, val)

    def threshold_reading_supported(self, threshold: 'char *', val: 'int *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_threshold_reading_supported(self, threshold, val)

    def discrete_event_supported(self, event: 'char *', val: 'int *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_discrete_event_supported(self, event, val)

    def discrete_event_readable(self, offset: 'int', val: 'int *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_discrete_event_readable(self, offset, val)

    def get_tolerance(self, val: 'int', tolerance: 'double *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_tolerance(self, val, tolerance)

    def get_accuracy(self, val: 'int', accuracy: 'double *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_accuracy(self, val, accuracy)

    def get_normal_min_specified(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_normal_min_specified(self)

    def get_normal_min(self, normal_min: 'double *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_normal_min(self, normal_min)

    def get_normal_max_specified(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_normal_max_specified(self)

    def get_normal_max(self, normal_max: 'double *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_normal_max(self, normal_max)

    def get_nominal_reading_specified(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_nominal_reading_specified(self)

    def get_nominal_reading(self, nominal_reading: 'double *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_nominal_reading(self, nominal_reading)

    def get_sensor_max(self, sensor_max: 'double *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_max(self, sensor_max)

    def get_sensor_min(self, sensor_min: 'double *') -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_min(self, sensor_min)

    def get_oem1(self) -> "int":
        return _OpenIPMI.ipmi_sensor_t_get_oem1(self)

    def get_sensor_id(self) -> "char *":
        return _OpenIPMI.ipmi_sensor_t_get_sensor_id(self)

    def get_mc(self) -> "ipmi_mc_t *":
        return _OpenIPMI.ipmi_sensor_t_get_mc(self)
ipmi_sensor_t_swigregister = _OpenIPMI.ipmi_sensor_t_swigregister
ipmi_sensor_t_swigregister(ipmi_sensor_t)
SENSOR_TYPE_TEMPERATURE = _OpenIPMI.SENSOR_TYPE_TEMPERATURE
SENSOR_TYPE_VOLTAGE = _OpenIPMI.SENSOR_TYPE_VOLTAGE
SENSOR_TYPE_CURRENT = _OpenIPMI.SENSOR_TYPE_CURRENT
SENSOR_TYPE_FAN = _OpenIPMI.SENSOR_TYPE_FAN
SENSOR_TYPE_PHYSICAL_SECURITY = _OpenIPMI.SENSOR_TYPE_PHYSICAL_SECURITY
SENSOR_TYPE_PLATFORM_SECURITY = _OpenIPMI.SENSOR_TYPE_PLATFORM_SECURITY
SENSOR_TYPE_PROCESSOR = _OpenIPMI.SENSOR_TYPE_PROCESSOR
SENSOR_TYPE_POWER_SUPPLY = _OpenIPMI.SENSOR_TYPE_POWER_SUPPLY
SENSOR_TYPE_POWER_UNIT = _OpenIPMI.SENSOR_TYPE_POWER_UNIT
SENSOR_TYPE_COOLING_DEVICE = _OpenIPMI.SENSOR_TYPE_COOLING_DEVICE
SENSOR_TYPE_OTHER_UNITS_BASED_SENSOR = _OpenIPMI.SENSOR_TYPE_OTHER_UNITS_BASED_SENSOR
SENSOR_TYPE_MEMORY = _OpenIPMI.SENSOR_TYPE_MEMORY
SENSOR_TYPE_DRIVE_SLOT = _OpenIPMI.SENSOR_TYPE_DRIVE_SLOT
SENSOR_TYPE_POWER_MEMORY_RESIZE = _OpenIPMI.SENSOR_TYPE_POWER_MEMORY_RESIZE
SENSOR_TYPE_SYSTEM_FIRMWARE_PROGRESS = _OpenIPMI.SENSOR_TYPE_SYSTEM_FIRMWARE_PROGRESS
SENSOR_TYPE_EVENT_LOGGING_DISABLED = _OpenIPMI.SENSOR_TYPE_EVENT_LOGGING_DISABLED
SENSOR_TYPE_WATCHDOG_1 = _OpenIPMI.SENSOR_TYPE_WATCHDOG_1
SENSOR_TYPE_SYSTEM_EVENT = _OpenIPMI.SENSOR_TYPE_SYSTEM_EVENT
SENSOR_TYPE_CRITICAL_INTERRUPT = _OpenIPMI.SENSOR_TYPE_CRITICAL_INTERRUPT
SENSOR_TYPE_BUTTON = _OpenIPMI.SENSOR_TYPE_BUTTON
SENSOR_TYPE_MODULE_BOARD = _OpenIPMI.SENSOR_TYPE_MODULE_BOARD
SENSOR_TYPE_MICROCONTROLLER_COPROCESSOR = _OpenIPMI.SENSOR_TYPE_MICROCONTROLLER_COPROCESSOR
SENSOR_TYPE_ADD_IN_CARD = _OpenIPMI.SENSOR_TYPE_ADD_IN_CARD
SENSOR_TYPE_CHASSIS = _OpenIPMI.SENSOR_TYPE_CHASSIS
SENSOR_TYPE_CHIP_SET = _OpenIPMI.SENSOR_TYPE_CHIP_SET
SENSOR_TYPE_OTHER_FRU = _OpenIPMI.SENSOR_TYPE_OTHER_FRU
SENSOR_TYPE_CABLE_INTERCONNECT = _OpenIPMI.SENSOR_TYPE_CABLE_INTERCONNECT
SENSOR_TYPE_TERMINATOR = _OpenIPMI.SENSOR_TYPE_TERMINATOR
SENSOR_TYPE_SYSTEM_BOOT_INITIATED = _OpenIPMI.SENSOR_TYPE_SYSTEM_BOOT_INITIATED
SENSOR_TYPE_BOOT_ERROR = _OpenIPMI.SENSOR_TYPE_BOOT_ERROR
SENSOR_TYPE_OS_BOOT = _OpenIPMI.SENSOR_TYPE_OS_BOOT
SENSOR_TYPE_OS_CRITICAL_STOP = _OpenIPMI.SENSOR_TYPE_OS_CRITICAL_STOP
SENSOR_TYPE_SLOT_CONNECTOR = _OpenIPMI.SENSOR_TYPE_SLOT_CONNECTOR
SENSOR_TYPE_SYSTEM_ACPI_POWER_STATE = _OpenIPMI.SENSOR_TYPE_SYSTEM_ACPI_POWER_STATE
SENSOR_TYPE_WATCHDOG_2 = _OpenIPMI.SENSOR_TYPE_WATCHDOG_2
SENSOR_TYPE_PLATFORM_ALERT = _OpenIPMI.SENSOR_TYPE_PLATFORM_ALERT
SENSOR_TYPE_ENTITY_PRESENCE = _OpenIPMI.SENSOR_TYPE_ENTITY_PRESENCE
SENSOR_TYPE_MONITOR_ASIC_IC = _OpenIPMI.SENSOR_TYPE_MONITOR_ASIC_IC
SENSOR_TYPE_LAN = _OpenIPMI.SENSOR_TYPE_LAN
SENSOR_TYPE_MANAGEMENT_SUBSYSTEM_HEALTH = _OpenIPMI.SENSOR_TYPE_MANAGEMENT_SUBSYSTEM_HEALTH
SENSOR_TYPE_BATTERY = _OpenIPMI.SENSOR_TYPE_BATTERY
EVENT_READING_TYPE_THRESHOLD = _OpenIPMI.EVENT_READING_TYPE_THRESHOLD
EVENT_READING_TYPE_DISCRETE_USAGE = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_USAGE
EVENT_READING_TYPE_DISCRETE_STATE = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_STATE
EVENT_READING_TYPE_DISCRETE_PREDICTIVE_FAILURE = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_PREDICTIVE_FAILURE
EVENT_READING_TYPE_DISCRETE_LIMIT_EXCEEDED = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_LIMIT_EXCEEDED
EVENT_READING_TYPE_DISCRETE_PERFORMANCE_MET = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_PERFORMANCE_MET
EVENT_READING_TYPE_DISCRETE_SEVERITY = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_SEVERITY
EVENT_READING_TYPE_DISCRETE_DEVICE_PRESENCE = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_DEVICE_PRESENCE
EVENT_READING_TYPE_DISCRETE_DEVICE_ENABLE = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_DEVICE_ENABLE
EVENT_READING_TYPE_DISCRETE_AVAILABILITY = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_AVAILABILITY
EVENT_READING_TYPE_DISCRETE_REDUNDANCY = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_REDUNDANCY
EVENT_READING_TYPE_DISCRETE_ACPI_POWER = _OpenIPMI.EVENT_READING_TYPE_DISCRETE_ACPI_POWER
EVENT_READING_TYPE_SENSOR_SPECIFIC = _OpenIPMI.EVENT_READING_TYPE_SENSOR_SPECIFIC
RATE_UNIT_NONE = _OpenIPMI.RATE_UNIT_NONE
RATE_UNIT_PER_US = _OpenIPMI.RATE_UNIT_PER_US
RATE_UNIT_PER_MS = _OpenIPMI.RATE_UNIT_PER_MS
RATE_UNIT_PER_SEC = _OpenIPMI.RATE_UNIT_PER_SEC
RATE_UNIT_MIN = _OpenIPMI.RATE_UNIT_MIN
RATE_UNIT_HOUR = _OpenIPMI.RATE_UNIT_HOUR
RATE_UNIT_DAY = _OpenIPMI.RATE_UNIT_DAY
UNIT_TYPE_UNSPECIFIED = _OpenIPMI.UNIT_TYPE_UNSPECIFIED
UNIT_TYPE_DEGREES_C = _OpenIPMI.UNIT_TYPE_DEGREES_C
UNIT_TYPE_DEGREES_F = _OpenIPMI.UNIT_TYPE_DEGREES_F
UNIT_TYPE_DEGREES_K = _OpenIPMI.UNIT_TYPE_DEGREES_K
UNIT_TYPE_VOLTS = _OpenIPMI.UNIT_TYPE_VOLTS
UNIT_TYPE_AMPS = _OpenIPMI.UNIT_TYPE_AMPS
UNIT_TYPE_WATTS = _OpenIPMI.UNIT_TYPE_WATTS
UNIT_TYPE_JOULES = _OpenIPMI.UNIT_TYPE_JOULES
UNIT_TYPE_COULOMBS = _OpenIPMI.UNIT_TYPE_COULOMBS
UNIT_TYPE_VA = _OpenIPMI.UNIT_TYPE_VA
UNIT_TYPE_NITS = _OpenIPMI.UNIT_TYPE_NITS
UNIT_TYPE_LUMENS = _OpenIPMI.UNIT_TYPE_LUMENS
UNIT_TYPE_LUX = _OpenIPMI.UNIT_TYPE_LUX
UNIT_TYPE_CANDELA = _OpenIPMI.UNIT_TYPE_CANDELA
UNIT_TYPE_KPA = _OpenIPMI.UNIT_TYPE_KPA
UNIT_TYPE_PSI = _OpenIPMI.UNIT_TYPE_PSI
UNIT_TYPE_NEWTONS = _OpenIPMI.UNIT_TYPE_NEWTONS
UNIT_TYPE_CFM = _OpenIPMI.UNIT_TYPE_CFM
UNIT_TYPE_RPM = _OpenIPMI.UNIT_TYPE_RPM
UNIT_TYPE_HZ = _OpenIPMI.UNIT_TYPE_HZ
UNIT_TYPE_USECONDS = _OpenIPMI.UNIT_TYPE_USECONDS
UNIT_TYPE_MSECONDS = _OpenIPMI.UNIT_TYPE_MSECONDS
UNIT_TYPE_SECONDS = _OpenIPMI.UNIT_TYPE_SECONDS
UNIT_TYPE_MINUTE = _OpenIPMI.UNIT_TYPE_MINUTE
UNIT_TYPE_HOUR = _OpenIPMI.UNIT_TYPE_HOUR
UNIT_TYPE_DAY = _OpenIPMI.UNIT_TYPE_DAY
UNIT_TYPE_WEEK = _OpenIPMI.UNIT_TYPE_WEEK
UNIT_TYPE_MIL = _OpenIPMI.UNIT_TYPE_MIL
UNIT_TYPE_INCHES = _OpenIPMI.UNIT_TYPE_INCHES
UNIT_TYPE_FEET = _OpenIPMI.UNIT_TYPE_FEET
UNIT_TYPE_CUBIC_INCHS = _OpenIPMI.UNIT_TYPE_CUBIC_INCHS
UNIT_TYPE_CUBIC_FEET = _OpenIPMI.UNIT_TYPE_CUBIC_FEET
UNIT_TYPE_MILLIMETERS = _OpenIPMI.UNIT_TYPE_MILLIMETERS
UNIT_TYPE_CENTIMETERS = _OpenIPMI.UNIT_TYPE_CENTIMETERS
UNIT_TYPE_METERS = _OpenIPMI.UNIT_TYPE_METERS
UNIT_TYPE_CUBIC_CENTIMETERS = _OpenIPMI.UNIT_TYPE_CUBIC_CENTIMETERS
UNIT_TYPE_CUBIC_METERS = _OpenIPMI.UNIT_TYPE_CUBIC_METERS
UNIT_TYPE_LITERS = _OpenIPMI.UNIT_TYPE_LITERS
UNIT_TYPE_FL_OZ = _OpenIPMI.UNIT_TYPE_FL_OZ
UNIT_TYPE_RADIANS = _OpenIPMI.UNIT_TYPE_RADIANS
UNIT_TYPE_SERADIANS = _OpenIPMI.UNIT_TYPE_SERADIANS
UNIT_TYPE_REVOLUTIONS = _OpenIPMI.UNIT_TYPE_REVOLUTIONS
UNIT_TYPE_CYCLES = _OpenIPMI.UNIT_TYPE_CYCLES
UNIT_TYPE_GRAVITIES = _OpenIPMI.UNIT_TYPE_GRAVITIES
UNIT_TYPE_OUNCES = _OpenIPMI.UNIT_TYPE_OUNCES
UNIT_TYPE_POUNDS = _OpenIPMI.UNIT_TYPE_POUNDS
UNIT_TYPE_FOOT_POUNDS = _OpenIPMI.UNIT_TYPE_FOOT_POUNDS
UNIT_TYPE_OUNCE_INCHES = _OpenIPMI.UNIT_TYPE_OUNCE_INCHES
UNIT_TYPE_GAUSS = _OpenIPMI.UNIT_TYPE_GAUSS
UNIT_TYPE_GILBERTS = _OpenIPMI.UNIT_TYPE_GILBERTS
UNIT_TYPE_HENRIES = _OpenIPMI.UNIT_TYPE_HENRIES
UNIT_TYPE_MHENRIES = _OpenIPMI.UNIT_TYPE_MHENRIES
UNIT_TYPE_FARADS = _OpenIPMI.UNIT_TYPE_FARADS
UNIT_TYPE_UFARADS = _OpenIPMI.UNIT_TYPE_UFARADS
UNIT_TYPE_OHMS = _OpenIPMI.UNIT_TYPE_OHMS
UNIT_TYPE_SIEMENS = _OpenIPMI.UNIT_TYPE_SIEMENS
UNIT_TYPE_MOLES = _OpenIPMI.UNIT_TYPE_MOLES
UNIT_TYPE_BECQUERELS = _OpenIPMI.UNIT_TYPE_BECQUERELS
UNIT_TYPE_PPM = _OpenIPMI.UNIT_TYPE_PPM
UNIT_TYPE_reserved1 = _OpenIPMI.UNIT_TYPE_reserved1
UNIT_TYPE_DECIBELS = _OpenIPMI.UNIT_TYPE_DECIBELS
UNIT_TYPE_DbA = _OpenIPMI.UNIT_TYPE_DbA
UNIT_TYPE_DbC = _OpenIPMI.UNIT_TYPE_DbC
UNIT_TYPE_GRAYS = _OpenIPMI.UNIT_TYPE_GRAYS
UNIT_TYPE_SIEVERTS = _OpenIPMI.UNIT_TYPE_SIEVERTS
UNIT_TYPE_COLOR_TEMP_DEG_K = _OpenIPMI.UNIT_TYPE_COLOR_TEMP_DEG_K
UNIT_TYPE_BITS = _OpenIPMI.UNIT_TYPE_BITS
UNIT_TYPE_KBITS = _OpenIPMI.UNIT_TYPE_KBITS
UNIT_TYPE_MBITS = _OpenIPMI.UNIT_TYPE_MBITS
UNIT_TYPE_GBITS = _OpenIPMI.UNIT_TYPE_GBITS
UNIT_TYPE_BYTES = _OpenIPMI.UNIT_TYPE_BYTES
UNIT_TYPE_KBYTES = _OpenIPMI.UNIT_TYPE_KBYTES
UNIT_TYPE_MBYTES = _OpenIPMI.UNIT_TYPE_MBYTES
UNIT_TYPE_GBYTES = _OpenIPMI.UNIT_TYPE_GBYTES
UNIT_TYPE_WORDS = _OpenIPMI.UNIT_TYPE_WORDS
UNIT_TYPE_DWORDS = _OpenIPMI.UNIT_TYPE_DWORDS
UNIT_TYPE_QWORDS = _OpenIPMI.UNIT_TYPE_QWORDS
UNIT_TYPE_LINES = _OpenIPMI.UNIT_TYPE_LINES
UNIT_TYPE_HITS = _OpenIPMI.UNIT_TYPE_HITS
UNIT_TYPE_MISSES = _OpenIPMI.UNIT_TYPE_MISSES
UNIT_TYPE_RETRIES = _OpenIPMI.UNIT_TYPE_RETRIES
UNIT_TYPE_RESETS = _OpenIPMI.UNIT_TYPE_RESETS
UNIT_TYPE_OVERRUNS = _OpenIPMI.UNIT_TYPE_OVERRUNS
UNIT_TYPE_UNDERRUNS = _OpenIPMI.UNIT_TYPE_UNDERRUNS
UNIT_TYPE_COLLISIONS = _OpenIPMI.UNIT_TYPE_COLLISIONS
UNIT_TYPE_PACKETS = _OpenIPMI.UNIT_TYPE_PACKETS
UNIT_TYPE_MESSAGES = _OpenIPMI.UNIT_TYPE_MESSAGES
UNIT_TYPE_CHARACTERS = _OpenIPMI.UNIT_TYPE_CHARACTERS
UNIT_TYPE_ERRORS = _OpenIPMI.UNIT_TYPE_ERRORS
UNIT_TYPE_CORRECTABLE_ERRORS = _OpenIPMI.UNIT_TYPE_CORRECTABLE_ERRORS
UNIT_TYPE_UNCORRECTABLE_ERRORS = _OpenIPMI.UNIT_TYPE_UNCORRECTABLE_ERRORS
UNIT_TYPE_FATAL_ERRORS = _OpenIPMI.UNIT_TYPE_FATAL_ERRORS
UNIT_TYPE_GRAMS = _OpenIPMI.UNIT_TYPE_GRAMS
MODIFIER_UNIT_NONE = _OpenIPMI.MODIFIER_UNIT_NONE
MODIFIER_UNIT_BASE_DIV_MOD = _OpenIPMI.MODIFIER_UNIT_BASE_DIV_MOD
MODIFIER_UNIT_BASE_MULT_MOD = _OpenIPMI.MODIFIER_UNIT_BASE_MULT_MOD
THRESHOLD_ACCESS_SUPPORT_NONE = _OpenIPMI.THRESHOLD_ACCESS_SUPPORT_NONE
THRESHOLD_ACCESS_SUPPORT_READABLE = _OpenIPMI.THRESHOLD_ACCESS_SUPPORT_READABLE
THRESHOLD_ACCESS_SUPPORT_SETTABLE = _OpenIPMI.THRESHOLD_ACCESS_SUPPORT_SETTABLE
THRESHOLD_ACCESS_SUPPORT_FIXED = _OpenIPMI.THRESHOLD_ACCESS_SUPPORT_FIXED
HYSTERESIS_SUPPORT_NONE = _OpenIPMI.HYSTERESIS_SUPPORT_NONE
HYSTERESIS_SUPPORT_READABLE = _OpenIPMI.HYSTERESIS_SUPPORT_READABLE
HYSTERESIS_SUPPORT_SETTABLE = _OpenIPMI.HYSTERESIS_SUPPORT_SETTABLE
HYSTERESIS_SUPPORT_FIXED = _OpenIPMI.HYSTERESIS_SUPPORT_FIXED
EVENT_SUPPORT_PER_STATE = _OpenIPMI.EVENT_SUPPORT_PER_STATE
EVENT_SUPPORT_ENTIRE_SENSOR = _OpenIPMI.EVENT_SUPPORT_ENTIRE_SENSOR
EVENT_SUPPORT_GLOBAL_ENABLE = _OpenIPMI.EVENT_SUPPORT_GLOBAL_ENABLE
EVENT_SUPPORT_NONE = _OpenIPMI.EVENT_SUPPORT_NONE
SENSOR_DIRECTION_UNSPECIFIED = _OpenIPMI.SENSOR_DIRECTION_UNSPECIFIED
SENSOR_DIRECTION_INPUT = _OpenIPMI.SENSOR_DIRECTION_INPUT
SENSOR_DIRECTION_OUTPUT = _OpenIPMI.SENSOR_DIRECTION_OUTPUT

class ipmi_sensor_id_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_sensor_id_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_sensor_id_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_sensor_id_t
    __del__ = lambda self: None

    def cmp(self, other: 'ipmi_sensor_id_t') -> "int":
        return _OpenIPMI.ipmi_sensor_id_t_cmp(self, other)

    def to_sensor(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_sensor_id_t_to_sensor(self, handler)
ipmi_sensor_id_t_swigregister = _OpenIPMI.ipmi_sensor_id_t_swigregister
ipmi_sensor_id_t_swigregister(ipmi_sensor_id_t)

class ipmi_control_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_control_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_control_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def get_name(self) -> "char *":
        return _OpenIPMI.ipmi_control_t_get_name(self)

    def get_id(self) -> "ipmi_control_id_t *":
        return _OpenIPMI.ipmi_control_t_get_id(self)

    def get_type_string(self) -> "char const *":
        return _OpenIPMI.ipmi_control_t_get_type_string(self)

    def get_type(self) -> "int":
        return _OpenIPMI.ipmi_control_t_get_type(self)

    def get_entity_id(self) -> "int":
        return _OpenIPMI.ipmi_control_t_get_entity_id(self)

    def get_entity_instance(self) -> "int":
        return _OpenIPMI.ipmi_control_t_get_entity_instance(self)

    def get_entity(self) -> "ipmi_entity_t *":
        return _OpenIPMI.ipmi_control_t_get_entity(self)

    def is_settable(self) -> "int":
        return _OpenIPMI.ipmi_control_t_is_settable(self)

    def is_readable(self) -> "int":
        return _OpenIPMI.ipmi_control_t_is_readable(self)

    def get_ignore_if_no_entity(self) -> "int":
        return _OpenIPMI.ipmi_control_t_get_ignore_if_no_entity(self)

    def get_control_id(self) -> "char *":
        return _OpenIPMI.ipmi_control_t_get_control_id(self)

    def has_events(self) -> "int":
        return _OpenIPMI.ipmi_control_t_has_events(self)

    def get_num_vals(self) -> "int":
        return _OpenIPMI.ipmi_control_t_get_num_vals(self)

    def set_val(self, val: 'intarray', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_control_t_set_val(self, val, handler)

    def get_val(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_control_t_get_val(self, handler)

    def add_event_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_control_t_add_event_handler(self, handler)

    def remove_event_handler(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_control_t_remove_event_handler(self, handler)

    def light_set_with_setting(self) -> "int":
        return _OpenIPMI.ipmi_control_t_light_set_with_setting(self)

    def light_is_color_supported(self, light_num: 'int', color: 'int') -> "int":
        return _OpenIPMI.ipmi_control_t_light_is_color_supported(self, light_num, color)

    def light_has_local_control(self, light_num: 'int') -> "int":
        return _OpenIPMI.ipmi_control_t_light_has_local_control(self, light_num)

    def set_light(self, settings: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_control_t_set_light(self, settings, handler)

    def get_light(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_control_t_get_light(self, handler)

    def get_num_light_values(self, light: 'int') -> "int":
        return _OpenIPMI.ipmi_control_t_get_num_light_values(self, light)

    def get_num_light_transitions(self, light: 'int', value: 'int') -> "int":
        return _OpenIPMI.ipmi_control_t_get_num_light_transitions(self, light, value)

    def get_light_color(self, light: 'int', value: 'int', transition: 'int') -> "int":
        return _OpenIPMI.ipmi_control_t_get_light_color(self, light, value, transition)

    def get_light_color_time(self, light: 'int', value: 'int', transition: 'int') -> "int":
        return _OpenIPMI.ipmi_control_t_get_light_color_time(self, light, value, transition)

    def identifier_set_val(self, val: 'intarray', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_control_t_identifier_set_val(self, val, handler)

    def identifier_get_val(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_control_t_identifier_get_val(self, handler)

    def identifier_get_max_length(self) -> "int":
        return _OpenIPMI.ipmi_control_t_identifier_get_max_length(self)
ipmi_control_t_swigregister = _OpenIPMI.ipmi_control_t_swigregister
ipmi_control_t_swigregister(ipmi_control_t)
CONTROL_LIGHT = _OpenIPMI.CONTROL_LIGHT
CONTROL_RELAY = _OpenIPMI.CONTROL_RELAY
CONTROL_DISPLAY = _OpenIPMI.CONTROL_DISPLAY
CONTROL_ALARM = _OpenIPMI.CONTROL_ALARM
CONTROL_RESET = _OpenIPMI.CONTROL_RESET
CONTROL_POWER = _OpenIPMI.CONTROL_POWER
CONTROL_FAN_SPEED = _OpenIPMI.CONTROL_FAN_SPEED
CONTROL_IDENTIFIER = _OpenIPMI.CONTROL_IDENTIFIER
CONTROL_ONE_SHOT_RESET = _OpenIPMI.CONTROL_ONE_SHOT_RESET
CONTROL_OUTPUT = _OpenIPMI.CONTROL_OUTPUT
CONTROL_ONE_SHOT_OUTPUT = _OpenIPMI.CONTROL_ONE_SHOT_OUTPUT
CONTROL_COLOR_BLACK = _OpenIPMI.CONTROL_COLOR_BLACK
CONTROL_COLOR_WHITE = _OpenIPMI.CONTROL_COLOR_WHITE
CONTROL_COLOR_RED = _OpenIPMI.CONTROL_COLOR_RED
CONTROL_COLOR_GREEN = _OpenIPMI.CONTROL_COLOR_GREEN
CONTROL_COLOR_BLUE = _OpenIPMI.CONTROL_COLOR_BLUE
CONTROL_COLOR_YELLOW = _OpenIPMI.CONTROL_COLOR_YELLOW
CONTROL_COLOR_ORANGE = _OpenIPMI.CONTROL_COLOR_ORANGE
CONTROL_NUM_COLORS = _OpenIPMI.CONTROL_NUM_COLORS

class ipmi_control_id_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_control_id_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_control_id_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_control_id_t
    __del__ = lambda self: None

    def cmp(self, other: 'ipmi_control_id_t') -> "int":
        return _OpenIPMI.ipmi_control_id_t_cmp(self, other)

    def to_control(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_control_id_t_to_control(self, handler)
ipmi_control_id_t_swigregister = _OpenIPMI.ipmi_control_id_t_swigregister
ipmi_control_id_t_swigregister(ipmi_control_id_t)

class ipmi_channel_info_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_channel_info_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_channel_info_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_channel_info_t
    __del__ = lambda self: None

    def copy(self) -> "ipmi_channel_info_t *":
        return _OpenIPMI.ipmi_channel_info_t_copy(self)

    def get_channel(self, channel: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_info_t_get_channel(self, channel)

    def get_medium(self, medium: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_info_t_get_medium(self, medium)

    def get_protocol_type(self, prot_type: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_info_t_get_protocol_type(self, prot_type)

    def get_session_support(self, sup: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_info_t_get_session_support(self, sup)

    def get_vendor_id(self) -> "char *":
        return _OpenIPMI.ipmi_channel_info_t_get_vendor_id(self)

    def get_aux_info(self) -> "char *":
        return _OpenIPMI.ipmi_channel_info_t_get_aux_info(self)
ipmi_channel_info_t_swigregister = _OpenIPMI.ipmi_channel_info_t_swigregister
ipmi_channel_info_t_swigregister(ipmi_channel_info_t)
CHANNEL_MEDIUM_IPMB = _OpenIPMI.CHANNEL_MEDIUM_IPMB
CHANNEL_MEDIUM_ICMB_V10 = _OpenIPMI.CHANNEL_MEDIUM_ICMB_V10
CHANNEL_MEDIUM_ICMB_V09 = _OpenIPMI.CHANNEL_MEDIUM_ICMB_V09
CHANNEL_MEDIUM_8023_LAN = _OpenIPMI.CHANNEL_MEDIUM_8023_LAN
CHANNEL_MEDIUM_RS232 = _OpenIPMI.CHANNEL_MEDIUM_RS232
CHANNEL_MEDIUM_OTHER_LAN = _OpenIPMI.CHANNEL_MEDIUM_OTHER_LAN
CHANNEL_MEDIUM_PCI_SMBUS = _OpenIPMI.CHANNEL_MEDIUM_PCI_SMBUS
CHANNEL_MEDIUM_SMBUS_v1 = _OpenIPMI.CHANNEL_MEDIUM_SMBUS_v1
CHANNEL_MEDIUM_SMBUS_v2 = _OpenIPMI.CHANNEL_MEDIUM_SMBUS_v2
CHANNEL_MEDIUM_USB_v1 = _OpenIPMI.CHANNEL_MEDIUM_USB_v1
CHANNEL_MEDIUM_USB_v2 = _OpenIPMI.CHANNEL_MEDIUM_USB_v2
CHANNEL_MEDIUM_SYS_INTF = _OpenIPMI.CHANNEL_MEDIUM_SYS_INTF
CHANNEL_PROTOCOL_IPMB = _OpenIPMI.CHANNEL_PROTOCOL_IPMB
CHANNEL_PROTOCOL_ICMB = _OpenIPMI.CHANNEL_PROTOCOL_ICMB
CHANNEL_PROTOCOL_SMBus = _OpenIPMI.CHANNEL_PROTOCOL_SMBus
CHANNEL_PROTOCOL_KCS = _OpenIPMI.CHANNEL_PROTOCOL_KCS
CHANNEL_PROTOCOL_SMIC = _OpenIPMI.CHANNEL_PROTOCOL_SMIC
CHANNEL_PROTOCOL_BT_v10 = _OpenIPMI.CHANNEL_PROTOCOL_BT_v10
CHANNEL_PROTOCOL_BT_v15 = _OpenIPMI.CHANNEL_PROTOCOL_BT_v15
CHANNEL_PROTOCOL_TMODE = _OpenIPMI.CHANNEL_PROTOCOL_TMODE
CHANNEL_SESSION_LESS = _OpenIPMI.CHANNEL_SESSION_LESS
CHANNEL_SINGLE_SESSION = _OpenIPMI.CHANNEL_SINGLE_SESSION
CHANNEL_MULTI_SESSION = _OpenIPMI.CHANNEL_MULTI_SESSION
CHANNEL_SESSION_BASED = _OpenIPMI.CHANNEL_SESSION_BASED

class ipmi_channel_access_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_channel_access_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_channel_access_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_channel_access_t
    __del__ = lambda self: None

    def copy(self) -> "ipmi_channel_access_t *":
        return _OpenIPMI.ipmi_channel_access_t_copy(self)

    def get_channel(self, channel: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_get_channel(self, channel)

    def get_alerting_enabled(self, enab: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_get_alerting_enabled(self, enab)

    def set_alerting_enabled(self, enab: 'int') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_set_alerting_enabled(self, enab)

    def get_per_msg_auth(self, msg_auth: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_get_per_msg_auth(self, msg_auth)

    def set_per_msg_auth(self, msg_auth: 'int') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_set_per_msg_auth(self, msg_auth)

    def get_user_auth(self, user_auth: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_get_user_auth(self, user_auth)

    def set_user_auth(self, user_auth: 'int') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_set_user_auth(self, user_auth)

    def get_access_mode(self, access_mode: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_get_access_mode(self, access_mode)

    def set_access_mode(self, access_mode: 'int') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_set_access_mode(self, access_mode)

    def get_privilege_limit(self, priv_limit: 'int *') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_get_privilege_limit(self, priv_limit)

    def set_privilege_limit(self, priv_limit: 'int') -> "int":
        return _OpenIPMI.ipmi_channel_access_t_set_privilege_limit(self, priv_limit)

    def setall(self) -> "int":
        return _OpenIPMI.ipmi_channel_access_t_setall(self)
ipmi_channel_access_t_swigregister = _OpenIPMI.ipmi_channel_access_t_swigregister
ipmi_channel_access_t_swigregister(ipmi_channel_access_t)
CHANNEL_ACCESS_MODE_DISABLED = _OpenIPMI.CHANNEL_ACCESS_MODE_DISABLED
CHANNEL_ACCESS_MODE_PRE_BOOT = _OpenIPMI.CHANNEL_ACCESS_MODE_PRE_BOOT
CHANNEL_ACCESS_MODE_ALWAYS = _OpenIPMI.CHANNEL_ACCESS_MODE_ALWAYS
CHANNEL_ACCESS_MODE_SHARED = _OpenIPMI.CHANNEL_ACCESS_MODE_SHARED
PRIVILEGE_CALLBACK = _OpenIPMI.PRIVILEGE_CALLBACK
PRIVILEGE_USER = _OpenIPMI.PRIVILEGE_USER
PRIVILEGE_OPERATOR = _OpenIPMI.PRIVILEGE_OPERATOR
PRIVILEGE_ADMIN = _OpenIPMI.PRIVILEGE_ADMIN
PRIVILEGE_OEM = _OpenIPMI.PRIVILEGE_OEM

class ipmi_user_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_user_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_user_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_user_t
    __del__ = lambda self: None

    def copy(self) -> "ipmi_user_t *":
        return _OpenIPMI.ipmi_user_t_copy(self)

    def get_channel(self, channel: 'int *') -> "int":
        return _OpenIPMI.ipmi_user_t_get_channel(self, channel)

    def get_num(self, num: 'int *') -> "int":
        return _OpenIPMI.ipmi_user_t_get_num(self, num)

    def set_num(self, num: 'int') -> "int":
        return _OpenIPMI.ipmi_user_t_set_num(self, num)

    def get_name(self) -> "char *":
        return _OpenIPMI.ipmi_user_t_get_name(self)

    def set_name(self, name: 'char *') -> "int":
        return _OpenIPMI.ipmi_user_t_set_name(self, name)

    def set_password(self, pw: 'char *') -> "int":
        return _OpenIPMI.ipmi_user_t_set_password(self, pw)

    def set_password2(self, pw: 'char *') -> "int":
        return _OpenIPMI.ipmi_user_t_set_password2(self, pw)

    def set_password_auto(self, pw: 'char *') -> "int":
        return _OpenIPMI.ipmi_user_t_set_password_auto(self, pw)

    def get_enable(self, enable: 'int *') -> "int":
        return _OpenIPMI.ipmi_user_t_get_enable(self, enable)

    def set_enable(self, val: 'int') -> "int":
        return _OpenIPMI.ipmi_user_t_set_enable(self, val)

    def get_link_auth_enabled(self, enable: 'int *') -> "int":
        return _OpenIPMI.ipmi_user_t_get_link_auth_enabled(self, enable)

    def set_link_auth_enabled(self, val: 'int') -> "int":
        return _OpenIPMI.ipmi_user_t_set_link_auth_enabled(self, val)

    def get_msg_auth_enabled(self, enable: 'int *') -> "int":
        return _OpenIPMI.ipmi_user_t_get_msg_auth_enabled(self, enable)

    def set_msg_auth_enabled(self, val: 'int') -> "int":
        return _OpenIPMI.ipmi_user_t_set_msg_auth_enabled(self, val)

    def get_access_cb_only(self, cb: 'int *') -> "int":
        return _OpenIPMI.ipmi_user_t_get_access_cb_only(self, cb)

    def set_access_cb_only(self, val: 'int') -> "int":
        return _OpenIPMI.ipmi_user_t_set_access_cb_only(self, val)

    def get_privilege_limit(self, limit: 'int *') -> "int":
        return _OpenIPMI.ipmi_user_t_get_privilege_limit(self, limit)

    def set_privilege_limit(self, val: 'int') -> "int":
        return _OpenIPMI.ipmi_user_t_set_privilege_limit(self, val)

    def get_session_limit(self, limit: 'int *') -> "int":
        return _OpenIPMI.ipmi_user_t_get_session_limit(self, limit)

    def set_session_limit(self, val: 'int') -> "int":
        return _OpenIPMI.ipmi_user_t_set_session_limit(self, val)

    def set_all(self) -> "int":
        return _OpenIPMI.ipmi_user_t_set_all(self)
ipmi_user_t_swigregister = _OpenIPMI.ipmi_user_t_swigregister
ipmi_user_t_swigregister(ipmi_user_t)

class ipmi_lanparm_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_lanparm_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_lanparm_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_lanparm_t
    __del__ = lambda self: None

    def get_mc_id(self) -> "ipmi_mcid_t *":
        return _OpenIPMI.ipmi_lanparm_t_get_mc_id(self)

    def get_channel(self) -> "int":
        return _OpenIPMI.ipmi_lanparm_t_get_channel(self)

    def get_parm(self, parm: 'int', set: 'int', block: 'int', handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_lanparm_t_get_parm(self, parm, set, block, handler)

    def set_parm(self, parm: 'int', value: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_lanparm_t_set_parm(self, parm, value, handler)

    def set_parm_array(self, parm: 'int', value: 'intarray', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_lanparm_t_set_parm_array(self, parm, value, handler)

    def get_config(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_lanparm_t_get_config(self, handler)

    def set_config(self, config: 'ipmi_lan_config_t', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_lanparm_t_set_config(self, config, handler)

    def clear_lock(self, config: 'ipmi_lan_config_t'=None, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_lanparm_t_clear_lock(self, config, handler)
ipmi_lanparm_t_swigregister = _OpenIPMI.ipmi_lanparm_t_swigregister
ipmi_lanparm_t_swigregister(ipmi_lanparm_t)
LANPARM_SET_IN_PROGRESS = _OpenIPMI.LANPARM_SET_IN_PROGRESS
LANPARM_AUTH_TYPE_SUPPORT = _OpenIPMI.LANPARM_AUTH_TYPE_SUPPORT
LANPARM_AUTH_TYPE_ENABLES = _OpenIPMI.LANPARM_AUTH_TYPE_ENABLES
LANPARM_IP_ADDRESS = _OpenIPMI.LANPARM_IP_ADDRESS
LANPARM_IP_ADDRESS_SRC = _OpenIPMI.LANPARM_IP_ADDRESS_SRC
LANPARM_MAC_ADDRESS = _OpenIPMI.LANPARM_MAC_ADDRESS
LANPARM_SUBNET_MASK = _OpenIPMI.LANPARM_SUBNET_MASK
LANPARM_IPV4_HDR_PARMS = _OpenIPMI.LANPARM_IPV4_HDR_PARMS
LANPARM_PRIMARY_RMCP_PORT = _OpenIPMI.LANPARM_PRIMARY_RMCP_PORT
LANPARM_SECONDARY_RMCP_PORT = _OpenIPMI.LANPARM_SECONDARY_RMCP_PORT
LANPARM_BMC_GENERATED_ARP_CNTL = _OpenIPMI.LANPARM_BMC_GENERATED_ARP_CNTL
LANPARM_GRATUIDOUS_ARP_INTERVAL = _OpenIPMI.LANPARM_GRATUIDOUS_ARP_INTERVAL
LANPARM_DEFAULT_GATEWAY_ADDR = _OpenIPMI.LANPARM_DEFAULT_GATEWAY_ADDR
LANPARM_DEFAULT_GATEWAY_MAC_ADDR = _OpenIPMI.LANPARM_DEFAULT_GATEWAY_MAC_ADDR
LANPARM_BACKUP_GATEWAY_ADDR = _OpenIPMI.LANPARM_BACKUP_GATEWAY_ADDR
LANPARM_BACKUP_GATEWAY_MAC_ADDR = _OpenIPMI.LANPARM_BACKUP_GATEWAY_MAC_ADDR
LANPARM_COMMUNITY_STRING = _OpenIPMI.LANPARM_COMMUNITY_STRING
LANPARM_NUM_DESTINATIONS = _OpenIPMI.LANPARM_NUM_DESTINATIONS
LANPARM_DEST_TYPE = _OpenIPMI.LANPARM_DEST_TYPE
LANPARM_DEST_ADDR = _OpenIPMI.LANPARM_DEST_ADDR
LANPARM_VLAN_ID = _OpenIPMI.LANPARM_VLAN_ID
LANPARM_VLAN_PRIORITY = _OpenIPMI.LANPARM_VLAN_PRIORITY
LANPARM_NUM_CIPHER_SUITE_ENTRIES = _OpenIPMI.LANPARM_NUM_CIPHER_SUITE_ENTRIES
LANPARM_CIPHER_SUITE_ENTRY_SUPPORT = _OpenIPMI.LANPARM_CIPHER_SUITE_ENTRY_SUPPORT
LANPARM_CIPHER_SUITE_ENTRY_PRIV = _OpenIPMI.LANPARM_CIPHER_SUITE_ENTRY_PRIV
LANPARM_DEST_VLAN_TAG = _OpenIPMI.LANPARM_DEST_VLAN_TAG

class ipmi_lan_config_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_lan_config_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_lan_config_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_lan_config_t
    __del__ = lambda self: None

    def get_val(self, parm: 'int', index: 'int *') -> "char *":
        return _OpenIPMI.ipmi_lan_config_t_get_val(self, parm, index)

    def set_val(self, parm: 'int', idx: 'int', type: 'char *', value: 'char *') -> "int":
        return _OpenIPMI.ipmi_lan_config_t_set_val(self, parm, idx, type, value)
ipmi_lan_config_t_swigregister = _OpenIPMI.ipmi_lan_config_t_swigregister
ipmi_lan_config_t_swigregister(ipmi_lan_config_t)

class ipmi_pef_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_pef_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_pef_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_pef_t
    __del__ = lambda self: None

    def get_mc_id(self) -> "ipmi_mcid_t *":
        return _OpenIPMI.ipmi_pef_t_get_mc_id(self)

    def get_parm(self, parm: 'int', set: 'int', block: 'int', handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_pef_t_get_parm(self, parm, set, block, handler)

    def set_parm(self, parm: 'int', value: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_pef_t_set_parm(self, parm, value, handler)

    def set_parm_array(self, parm: 'int', value: 'intarray', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_pef_t_set_parm_array(self, parm, value, handler)

    def get_config(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_pef_t_get_config(self, handler)

    def set_config(self, config: 'ipmi_pef_config_t', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_pef_t_set_config(self, config, handler)

    def clear_lock(self, config: 'ipmi_pef_config_t'=None, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_pef_t_clear_lock(self, config, handler)
ipmi_pef_t_swigregister = _OpenIPMI.ipmi_pef_t_swigregister
ipmi_pef_t_swigregister(ipmi_pef_t)
PEFPARM_SET_IN_PROGRESS = _OpenIPMI.PEFPARM_SET_IN_PROGRESS
PEFPARM_CONTROL = _OpenIPMI.PEFPARM_CONTROL
PEFPARM_ACTION_GLOBAL_CONTROL = _OpenIPMI.PEFPARM_ACTION_GLOBAL_CONTROL
PEFPARM_STARTUP_DELAY = _OpenIPMI.PEFPARM_STARTUP_DELAY
PEFPARM_ALERT_STARTUP_DELAY = _OpenIPMI.PEFPARM_ALERT_STARTUP_DELAY
PEFPARM_NUM_EVENT_FILTERS = _OpenIPMI.PEFPARM_NUM_EVENT_FILTERS
PEFPARM_EVENT_FILTER_TABLE = _OpenIPMI.PEFPARM_EVENT_FILTER_TABLE
PEFPARM_EVENT_FILTER_TABLE_DATA1 = _OpenIPMI.PEFPARM_EVENT_FILTER_TABLE_DATA1
PEFPARM_NUM_ALERT_POLICIES = _OpenIPMI.PEFPARM_NUM_ALERT_POLICIES
PEFPARM_ALERT_POLICY_TABLE = _OpenIPMI.PEFPARM_ALERT_POLICY_TABLE
PEFPARM_SYSTEM_GUID = _OpenIPMI.PEFPARM_SYSTEM_GUID
PEFPARM_NUM_ALERT_STRINGS = _OpenIPMI.PEFPARM_NUM_ALERT_STRINGS
PEFPARM_ALERT_STRING_KEY = _OpenIPMI.PEFPARM_ALERT_STRING_KEY
PEFPARM_ALERT_STRING = _OpenIPMI.PEFPARM_ALERT_STRING

class ipmi_pef_config_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_pef_config_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_pef_config_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_pef_config_t
    __del__ = lambda self: None

    def get_val(self, parm: 'int', index: 'int *') -> "char *":
        return _OpenIPMI.ipmi_pef_config_t_get_val(self, parm, index)

    def set_val(self, parm: 'int', idx: 'int', type: 'char *', value: 'char *') -> "int":
        return _OpenIPMI.ipmi_pef_config_t_set_val(self, parm, idx, type, value)
ipmi_pef_config_t_swigregister = _OpenIPMI.ipmi_pef_config_t_swigregister
ipmi_pef_config_t_swigregister(ipmi_pef_config_t)

class ipmi_pet_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_pet_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_pet_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_pet_t
    __del__ = lambda self: None

    def get_mc_id(self) -> "ipmi_mcid_t *":
        return _OpenIPMI.ipmi_pet_t_get_mc_id(self)

    def get_channel(self) -> "int":
        return _OpenIPMI.ipmi_pet_t_get_channel(self)

    def get_ip_addr(self) -> "char *":
        return _OpenIPMI.ipmi_pet_t_get_ip_addr(self)

    def get_mac_addr(self) -> "char *":
        return _OpenIPMI.ipmi_pet_t_get_mac_addr(self)

    def get_eft_sel(self) -> "int":
        return _OpenIPMI.ipmi_pet_t_get_eft_sel(self)

    def get_policy_num(self) -> "int":
        return _OpenIPMI.ipmi_pet_t_get_policy_num(self)

    def get_apt_sel(self) -> "int":
        return _OpenIPMI.ipmi_pet_t_get_apt_sel(self)

    def get_lan_dest_sel(self) -> "int":
        return _OpenIPMI.ipmi_pet_t_get_lan_dest_sel(self)
ipmi_pet_t_swigregister = _OpenIPMI.ipmi_pet_t_swigregister
ipmi_pet_t_swigregister(ipmi_pet_t)

class ipmi_cmdlang_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_cmdlang_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_cmdlang_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_cmdlang_t
    __del__ = lambda self: None

    def handle(self, icmd: 'char const *') -> "void":
        return _OpenIPMI.ipmi_cmdlang_t_handle(self, icmd)

    def is_help(self) -> "int":
        return _OpenIPMI.ipmi_cmdlang_t_is_help(self)

    def get_err(self) -> "int":
        return _OpenIPMI.ipmi_cmdlang_t_get_err(self)

    def get_errstr(self) -> "char *":
        return _OpenIPMI.ipmi_cmdlang_t_get_errstr(self)

    def get_objstr(self) -> "char *":
        return _OpenIPMI.ipmi_cmdlang_t_get_objstr(self)

    def get_location(self) -> "char *":
        return _OpenIPMI.ipmi_cmdlang_t_get_location(self)
ipmi_cmdlang_t_swigregister = _OpenIPMI.ipmi_cmdlang_t_swigregister
ipmi_cmdlang_t_swigregister(ipmi_cmdlang_t)

class ipmi_cmdlang_event_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_cmdlang_event_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_cmdlang_event_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_cmdlang_event_t
    __del__ = lambda self: None

    def restart(self) -> "void":
        return _OpenIPMI.ipmi_cmdlang_event_t_restart(self)

    def next_field(self, level: 'unsigned int *', type: 'char const **', name: 'char **', value: 'char **') -> "int":
        return _OpenIPMI.ipmi_cmdlang_event_t_next_field(self, level, type, name, value)
ipmi_cmdlang_event_t_swigregister = _OpenIPMI.ipmi_cmdlang_event_t_swigregister
ipmi_cmdlang_event_t_swigregister(ipmi_cmdlang_event_t)

class ipmi_sol_conn_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_sol_conn_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_sol_conn_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_sol_conn_t
    __del__ = lambda self: None

    def set_ACK_timeout(self, timeout_usec: 'int') -> "void":
        return _OpenIPMI.ipmi_sol_conn_t_set_ACK_timeout(self, timeout_usec)

    def get_ACK_timeout(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_get_ACK_timeout(self)

    def set_ACK_retries(self, retries: 'int') -> "void":
        return _OpenIPMI.ipmi_sol_conn_t_set_ACK_retries(self, retries)

    def get_ACK_retries(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_get_ACK_retries(self)

    def set_use_authentication(self, use_authentication: 'int') -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_set_use_authentication(self, use_authentication)

    def get_use_authentication(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_get_use_authentication(self)

    def set_use_encryption(self, use_encryption: 'int') -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_set_use_encryption(self, use_encryption)

    def get_use_encryption(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_get_use_encryption(self)

    def set_shared_serial_alert_behavior(self, behavior: 'int') -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_set_shared_serial_alert_behavior(self, behavior)

    def get_shared_serial_alert_behavior(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_get_shared_serial_alert_behavior(self)

    def set_deassert_CTS_DCD_DSR_on_connect(self, arg2: 'int') -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_set_deassert_CTS_DCD_DSR_on_connect(self, arg2)

    def get_deassert_CTS_DCD_DSR_on_connect(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_get_deassert_CTS_DCD_DSR_on_connect(self)

    def set_bit_rate(self, rate: 'unsigned int') -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_set_bit_rate(self, rate)

    def get_bit_rate(self) -> "unsigned int":
        return _OpenIPMI.ipmi_sol_conn_t_get_bit_rate(self)

    def open(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_open(self)

    def close(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_close(self)

    def force_close(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_force_close(self)

    def write(self, buf: 'charbuf', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_write(self, buf, handler)

    def release_nack(self) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_release_nack(self)

    def send_break(self, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_send_break(self, handler)

    def set_CTS_assertable(self, asserted: 'int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_set_CTS_assertable(self, asserted, handler)

    def set_DCD_DSR_asserted(self, asserted: 'int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_set_DCD_DSR_asserted(self, asserted, handler)

    def set_RI_asserted(self, asserted: 'int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_set_RI_asserted(self, asserted, handler)

    def flush(self, queue_selectors: 'int', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_sol_conn_t_flush(self, queue_selectors, handler)
ipmi_sol_conn_t_swigregister = _OpenIPMI.ipmi_sol_conn_t_swigregister
ipmi_sol_conn_t_swigregister(ipmi_sol_conn_t)
sol_state_closed = _OpenIPMI.sol_state_closed
sol_state_connecting = _OpenIPMI.sol_state_connecting
sol_state_connected = _OpenIPMI.sol_state_connected
sol_state_connected_ctu = _OpenIPMI.sol_state_connected_ctu
sol_state_closing = _OpenIPMI.sol_state_closing
sol_serial_alerts_fail = _OpenIPMI.sol_serial_alerts_fail
sol_serial_alerts_deferred = _OpenIPMI.sol_serial_alerts_deferred
sol_serial_alerts_succeed = _OpenIPMI.sol_serial_alerts_succeed
SOL_BIT_RATE_DEFAULT = _OpenIPMI.SOL_BIT_RATE_DEFAULT
SOL_BIT_RATE_9600 = _OpenIPMI.SOL_BIT_RATE_9600
SOL_BIT_RATE_19200 = _OpenIPMI.SOL_BIT_RATE_19200
SOL_BIT_RATE_38400 = _OpenIPMI.SOL_BIT_RATE_38400
SOL_BIT_RATE_57600 = _OpenIPMI.SOL_BIT_RATE_57600
SOL_BIT_RATE_115200 = _OpenIPMI.SOL_BIT_RATE_115200
SOL_BMC_TRANSMIT_QUEUE = _OpenIPMI.SOL_BMC_TRANSMIT_QUEUE
SOL_BMC_RECEIVE_QUEUE = _OpenIPMI.SOL_BMC_RECEIVE_QUEUE
SOL_MANAGEMENT_CONSOLE_TRANSMIT_QUEUE = _OpenIPMI.SOL_MANAGEMENT_CONSOLE_TRANSMIT_QUEUE
SOL_MANAGEMENT_CONSOLE_RECEIVE_QUEUE = _OpenIPMI.SOL_MANAGEMENT_CONSOLE_RECEIVE_QUEUE
SOL_BMC_QUEUES = _OpenIPMI.SOL_BMC_QUEUES
SOL_MANAGEMENT_CONSOLE_QUEUES = _OpenIPMI.SOL_MANAGEMENT_CONSOLE_QUEUES
SOL_ALL_QUEUES = _OpenIPMI.SOL_ALL_QUEUES

class ipmi_sol_config_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_sol_config_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_sol_config_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_sol_config_t
    __del__ = lambda self: None

    def get_val(self, parm: 'int', index: 'int *') -> "char *":
        return _OpenIPMI.ipmi_sol_config_t_get_val(self, parm, index)

    def set_val(self, parm: 'int', idx: 'int', type: 'char *', value: 'char *') -> "int":
        return _OpenIPMI.ipmi_sol_config_t_set_val(self, parm, idx, type, value)
ipmi_sol_config_t_swigregister = _OpenIPMI.ipmi_sol_config_t_swigregister
ipmi_sol_config_t_swigregister(ipmi_sol_config_t)

class ipmi_solparm_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ipmi_solparm_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ipmi_solparm_t, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _OpenIPMI.delete_ipmi_solparm_t
    __del__ = lambda self: None

    def get_mc_id(self) -> "ipmi_mcid_t *":
        return _OpenIPMI.ipmi_solparm_t_get_mc_id(self)

    def get_channel(self) -> "int":
        return _OpenIPMI.ipmi_solparm_t_get_channel(self)

    def get_parm(self, parm: 'int', set: 'int', block: 'int', handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_solparm_t_get_parm(self, parm, set, block, handler)

    def set_parm(self, parm: 'int', value: 'char *', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_solparm_t_set_parm(self, parm, value, handler)

    def set_parm_array(self, parm: 'int', value: 'intarray', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_solparm_t_set_parm_array(self, parm, value, handler)

    def get_config(self, handler: 'swig_cb *') -> "int":
        return _OpenIPMI.ipmi_solparm_t_get_config(self, handler)

    def set_config(self, config: 'ipmi_sol_config_t', handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_solparm_t_set_config(self, config, handler)

    def clear_lock(self, config: 'ipmi_sol_config_t'=None, handler: 'swig_cb *'=None) -> "int":
        return _OpenIPMI.ipmi_solparm_t_clear_lock(self, config, handler)
ipmi_solparm_t_swigregister = _OpenIPMI.ipmi_solparm_t_swigregister
ipmi_solparm_t_swigregister(ipmi_solparm_t)
SOLPARM_SET_IN_PROGRESS = _OpenIPMI.SOLPARM_SET_IN_PROGRESS
SOLPARM_ENABLE = _OpenIPMI.SOLPARM_ENABLE
SOLPARM_AUTHENTICATION = _OpenIPMI.SOLPARM_AUTHENTICATION
SOLPARM_CHAR_SETTINGS = _OpenIPMI.SOLPARM_CHAR_SETTINGS
SOLPARM_RETRY = _OpenIPMI.SOLPARM_RETRY
SOLPARM_NONVOLATILE_BITRATE = _OpenIPMI.SOLPARM_NONVOLATILE_BITRATE
SOLPARM_VOLATILE_BITRATE = _OpenIPMI.SOLPARM_VOLATILE_BITRATE
SOLPARM_PAYLOAD_CHANNEL = _OpenIPMI.SOLPARM_PAYLOAD_CHANNEL
SOLPARM_PAYLOAD_PORT_NUMBER = _OpenIPMI.SOLPARM_PAYLOAD_PORT_NUMBER


def enable_debug_malloc() -> "void":
    return _OpenIPMI.enable_debug_malloc()
enable_debug_malloc = _OpenIPMI.enable_debug_malloc

def enable_debug_msg() -> "void":
    return _OpenIPMI.enable_debug_msg()
enable_debug_msg = _OpenIPMI.enable_debug_msg

def disable_debug_msg() -> "void":
    return _OpenIPMI.disable_debug_msg()
disable_debug_msg = _OpenIPMI.disable_debug_msg

def enable_debug_rawmsg() -> "void":
    return _OpenIPMI.enable_debug_rawmsg()
enable_debug_rawmsg = _OpenIPMI.enable_debug_rawmsg

def disable_debug_rawmsg() -> "void":
    return _OpenIPMI.disable_debug_rawmsg()
disable_debug_rawmsg = _OpenIPMI.disable_debug_rawmsg

def init_glib() -> "int":
    return _OpenIPMI.init_glib()
init_glib = _OpenIPMI.init_glib

def init_glib12() -> "int":
    return _OpenIPMI.init_glib12()
init_glib12 = _OpenIPMI.init_glib12

def init_tcl() -> "int":
    return _OpenIPMI.init_tcl()
init_tcl = _OpenIPMI.init_tcl

def init_posix() -> "int":
    return _OpenIPMI.init_posix()
init_posix = _OpenIPMI.init_posix

def init() -> "int":
    return _OpenIPMI.init()
init = _OpenIPMI.init

def shutdown_everything() -> "void":
    return _OpenIPMI.shutdown_everything()
shutdown_everything = _OpenIPMI.shutdown_everything

def wait_io(timeout: 'int') -> "void":
    return _OpenIPMI.wait_io(timeout)
wait_io = _OpenIPMI.wait_io
ebadf = _OpenIPMI.ebadf
einval = _OpenIPMI.einval
e2big = _OpenIPMI.e2big
enomem = _OpenIPMI.enomem
enoent = _OpenIPMI.enoent
ecanceled = _OpenIPMI.ecanceled
enosys = _OpenIPMI.enosys
eexist = _OpenIPMI.eexist
eagain = _OpenIPMI.eagain
eperm = _OpenIPMI.eperm
EVENT_NOT_HANDLED = _OpenIPMI.EVENT_NOT_HANDLED
EVENT_HANDLED = _OpenIPMI.EVENT_HANDLED
EVENT_HANDLED_PASS = _OpenIPMI.EVENT_HANDLED_PASS

def open_domain(name: 'char *', args: 'argarray', done: 'swig_cb *'=None, up: 'swig_cb *'=None) -> "ipmi_domain_id_t *":
    return _OpenIPMI.open_domain(name, args, done, up)
open_domain = _OpenIPMI.open_domain

def open_domain2(name: 'char *', args: 'argarray', done: 'swig_cb *'=None, up: 'swig_cb *'=None) -> "ipmi_domain_id_t *":
    return _OpenIPMI.open_domain2(name, args, done, up)
open_domain2 = _OpenIPMI.open_domain2

def open_domain3(name: 'char *', options: 'argarray', args: 'iargarray', done: 'swig_cb *'=None, up: 'swig_cb *'=None) -> "ipmi_domain_id_t *":
    return _OpenIPMI.open_domain3(name, options, args, done, up)
open_domain3 = _OpenIPMI.open_domain3

def parse_args_iter_help(help_cb: 'swig_cb *') -> "void":
    return _OpenIPMI.parse_args_iter_help(help_cb)
parse_args_iter_help = _OpenIPMI.parse_args_iter_help

def parse_option_help() -> "char const *":
    return _OpenIPMI.parse_option_help()
parse_option_help = _OpenIPMI.parse_option_help

def add_domain_change_handler(handler: 'swig_cb *') -> "int":
    return _OpenIPMI.add_domain_change_handler(handler)
add_domain_change_handler = _OpenIPMI.add_domain_change_handler

def remove_domain_change_handler(handler: 'swig_cb *') -> "int":
    return _OpenIPMI.remove_domain_change_handler(handler)
remove_domain_change_handler = _OpenIPMI.remove_domain_change_handler

def set_log_handler(handler: 'swig_cb *'=None) -> "void":
    return _OpenIPMI.set_log_handler(handler)
set_log_handler = _OpenIPMI.set_log_handler

def color_string(color: 'int') -> "char *":
    return _OpenIPMI.color_string(color)
color_string = _OpenIPMI.color_string

def lanparm_parm_to_str(parm: 'int') -> "char *":
    return _OpenIPMI.lanparm_parm_to_str(parm)
lanparm_parm_to_str = _OpenIPMI.lanparm_parm_to_str

def lanparm_str_to_parm(str: 'char *') -> "int":
    return _OpenIPMI.lanparm_str_to_parm(str)
lanparm_str_to_parm = _OpenIPMI.lanparm_str_to_parm

def lanconfig_enum_val(parm: 'int', val: 'int', nval: 'int *', sval: 'char const **') -> "int *, char const **":
    return _OpenIPMI.lanconfig_enum_val(parm, val, nval, sval)
lanconfig_enum_val = _OpenIPMI.lanconfig_enum_val

def lanconfig_enum_idx(parm: 'int', idx: 'int', sval: 'char const **') -> "char const **":
    return _OpenIPMI.lanconfig_enum_idx(parm, idx, sval)
lanconfig_enum_idx = _OpenIPMI.lanconfig_enum_idx

def pef_parm_to_str(parm: 'int') -> "char *":
    return _OpenIPMI.pef_parm_to_str(parm)
pef_parm_to_str = _OpenIPMI.pef_parm_to_str

def pef_str_to_parm(str: 'char *') -> "int":
    return _OpenIPMI.pef_str_to_parm(str)
pef_str_to_parm = _OpenIPMI.pef_str_to_parm

def pefconfig_enum_val(parm: 'int', val: 'int', nval: 'int *', sval: 'char const **') -> "int *, char const **":
    return _OpenIPMI.pefconfig_enum_val(parm, val, nval, sval)
pefconfig_enum_val = _OpenIPMI.pefconfig_enum_val

def pefconfig_enum_idx(parm: 'int', idx: 'int', sval: 'char const **') -> "char const **":
    return _OpenIPMI.pefconfig_enum_idx(parm, idx, sval)
pefconfig_enum_idx = _OpenIPMI.pefconfig_enum_idx

def solparm_parm_to_str(parm: 'int') -> "char *":
    return _OpenIPMI.solparm_parm_to_str(parm)
solparm_parm_to_str = _OpenIPMI.solparm_parm_to_str

def solparm_str_to_parm(str: 'char *') -> "int":
    return _OpenIPMI.solparm_str_to_parm(str)
solparm_str_to_parm = _OpenIPMI.solparm_str_to_parm

def solconfig_enum_val(parm: 'int', val: 'int', nval: 'int *', sval: 'char const **') -> "int *, char const **":
    return _OpenIPMI.solconfig_enum_val(parm, val, nval, sval)
solconfig_enum_val = _OpenIPMI.solconfig_enum_val

def solconfig_enum_idx(parm: 'int', idx: 'int', sval: 'char const **') -> "char const **":
    return _OpenIPMI.solconfig_enum_idx(parm, idx, sval)
solconfig_enum_idx = _OpenIPMI.solconfig_enum_idx

def get_threshold_access_support_string(val: 'int') -> "char *":
    return _OpenIPMI.get_threshold_access_support_string(val)
get_threshold_access_support_string = _OpenIPMI.get_threshold_access_support_string

def get_hysteresis_support_string(val: 'int') -> "char *":
    return _OpenIPMI.get_hysteresis_support_string(val)
get_hysteresis_support_string = _OpenIPMI.get_hysteresis_support_string

def get_event_support_string(val: 'int') -> "char *":
    return _OpenIPMI.get_event_support_string(val)
get_event_support_string = _OpenIPMI.get_event_support_string

def channel_medium_string(val: 'int') -> "char *":
    return _OpenIPMI.channel_medium_string(val)
channel_medium_string = _OpenIPMI.channel_medium_string

def channel_protocol_string(val: 'int') -> "char *":
    return _OpenIPMI.channel_protocol_string(val)
channel_protocol_string = _OpenIPMI.channel_protocol_string

def channel_session_support_string(val: 'int') -> "char *":
    return _OpenIPMI.channel_session_support_string(val)
channel_session_support_string = _OpenIPMI.channel_session_support_string

def channel_access_mode_string(val: 'int') -> "char *":
    return _OpenIPMI.channel_access_mode_string(val)
channel_access_mode_string = _OpenIPMI.channel_access_mode_string

def privilege_string(val: 'int') -> "char *":
    return _OpenIPMI.privilege_string(val)
privilege_string = _OpenIPMI.privilege_string

def authtype_string(val: 'int') -> "char *":
    return _OpenIPMI.authtype_string(val)
authtype_string = _OpenIPMI.authtype_string

def get_error_string(val: 'unsigned int') -> "char *":
    return _OpenIPMI.get_error_string(val)
get_error_string = _OpenIPMI.get_error_string
TIMEOUT_FOREVER = _OpenIPMI.TIMEOUT_FOREVER

def alloc_empty_args(con_type: 'char *') -> "ipmi_args_t *":
    return _OpenIPMI.alloc_empty_args(con_type)
alloc_empty_args = _OpenIPMI.alloc_empty_args

def alloc_parse_args(args: 'argarray') -> "ipmi_args_t *":
    return _OpenIPMI.alloc_parse_args(args)
alloc_parse_args = _OpenIPMI.alloc_parse_args
ENTITY_ID_UNSPECIFIED = _OpenIPMI.ENTITY_ID_UNSPECIFIED
ENTITY_ID_OTHER = _OpenIPMI.ENTITY_ID_OTHER
ENTITY_ID_UNKOWN = _OpenIPMI.ENTITY_ID_UNKOWN
ENTITY_ID_PROCESSOR = _OpenIPMI.ENTITY_ID_PROCESSOR
ENTITY_ID_DISK = _OpenIPMI.ENTITY_ID_DISK
ENTITY_ID_PERIPHERAL = _OpenIPMI.ENTITY_ID_PERIPHERAL
ENTITY_ID_SYSTEM_MANAGEMENT_MODULE = _OpenIPMI.ENTITY_ID_SYSTEM_MANAGEMENT_MODULE
ENTITY_ID_SYSTEM_BOARD = _OpenIPMI.ENTITY_ID_SYSTEM_BOARD
ENTITY_ID_MEMORY_MODULE = _OpenIPMI.ENTITY_ID_MEMORY_MODULE
ENTITY_ID_PROCESSOR_MODULE = _OpenIPMI.ENTITY_ID_PROCESSOR_MODULE
ENTITY_ID_POWER_SUPPLY = _OpenIPMI.ENTITY_ID_POWER_SUPPLY
ENTITY_ID_ADD_IN_CARD = _OpenIPMI.ENTITY_ID_ADD_IN_CARD
ENTITY_ID_FRONT_PANEL_BOARD = _OpenIPMI.ENTITY_ID_FRONT_PANEL_BOARD
ENTITY_ID_BACK_PANEL_BOARD = _OpenIPMI.ENTITY_ID_BACK_PANEL_BOARD
ENTITY_ID_POWER_SYSTEM_BOARD = _OpenIPMI.ENTITY_ID_POWER_SYSTEM_BOARD
ENTITY_ID_DRIVE_BACKPLANE = _OpenIPMI.ENTITY_ID_DRIVE_BACKPLANE
ENTITY_ID_SYSTEM_INTERNAL_EXPANSION_BOARD = _OpenIPMI.ENTITY_ID_SYSTEM_INTERNAL_EXPANSION_BOARD
ENTITY_ID_OTHER_SYSTEM_BOARD = _OpenIPMI.ENTITY_ID_OTHER_SYSTEM_BOARD
ENTITY_ID_PROCESSOR_BOARD = _OpenIPMI.ENTITY_ID_PROCESSOR_BOARD
ENTITY_ID_POWER_UNIT = _OpenIPMI.ENTITY_ID_POWER_UNIT
ENTITY_ID_POWER_MODULE = _OpenIPMI.ENTITY_ID_POWER_MODULE
ENTITY_ID_POWER_MANAGEMENT_BOARD = _OpenIPMI.ENTITY_ID_POWER_MANAGEMENT_BOARD
ENTITY_ID_CHASSIS_BACK_PANEL_BOARD = _OpenIPMI.ENTITY_ID_CHASSIS_BACK_PANEL_BOARD
ENTITY_ID_SYSTEM_CHASSIS = _OpenIPMI.ENTITY_ID_SYSTEM_CHASSIS
ENTITY_ID_SUB_CHASSIS = _OpenIPMI.ENTITY_ID_SUB_CHASSIS
ENTITY_ID_OTHER_CHASSIS_BOARD = _OpenIPMI.ENTITY_ID_OTHER_CHASSIS_BOARD
ENTITY_ID_DISK_DRIVE_BAY = _OpenIPMI.ENTITY_ID_DISK_DRIVE_BAY
ENTITY_ID_PERIPHERAL_BAY = _OpenIPMI.ENTITY_ID_PERIPHERAL_BAY
ENTITY_ID_DEVICE_BAY = _OpenIPMI.ENTITY_ID_DEVICE_BAY
ENTITY_ID_FAN_COOLING = _OpenIPMI.ENTITY_ID_FAN_COOLING
ENTITY_ID_COOLING_UNIT = _OpenIPMI.ENTITY_ID_COOLING_UNIT
ENTITY_ID_CABLE_INTERCONNECT = _OpenIPMI.ENTITY_ID_CABLE_INTERCONNECT
ENTITY_ID_MEMORY_DEVICE = _OpenIPMI.ENTITY_ID_MEMORY_DEVICE
ENTITY_ID_SYSTEM_MANAGEMENT_SOFTWARE = _OpenIPMI.ENTITY_ID_SYSTEM_MANAGEMENT_SOFTWARE
ENTITY_ID_BIOS = _OpenIPMI.ENTITY_ID_BIOS
ENTITY_ID_OPERATING_SYSTEM = _OpenIPMI.ENTITY_ID_OPERATING_SYSTEM
ENTITY_ID_SYSTEM_BUS = _OpenIPMI.ENTITY_ID_SYSTEM_BUS
ENTITY_ID_GROUP = _OpenIPMI.ENTITY_ID_GROUP
ENTITY_ID_REMOTE_MGMT_COMM_DEVICE = _OpenIPMI.ENTITY_ID_REMOTE_MGMT_COMM_DEVICE
ENTITY_ID_EXTERNAL_ENVIRONMENT = _OpenIPMI.ENTITY_ID_EXTERNAL_ENVIRONMENT
ENTITY_ID_BATTERY = _OpenIPMI.ENTITY_ID_BATTERY
ENTITY_ID_PROCESSING_BLADE = _OpenIPMI.ENTITY_ID_PROCESSING_BLADE
ENTITY_ID_CONNECTIVITY_SWITCH = _OpenIPMI.ENTITY_ID_CONNECTIVITY_SWITCH
ENTITY_ID_PROCESSOR_MEMORY_MODULE = _OpenIPMI.ENTITY_ID_PROCESSOR_MEMORY_MODULE
ENTITY_ID_IO_MODULE = _OpenIPMI.ENTITY_ID_IO_MODULE
ENTITY_ID_PROCESSOR_IO_MODULE = _OpenIPMI.ENTITY_ID_PROCESSOR_IO_MODULE
ENTITY_ID_MGMT_CONTROLLER_FIRMWARE = _OpenIPMI.ENTITY_ID_MGMT_CONTROLLER_FIRMWARE
ENTITY_ID_IPMI_CHANNEL = _OpenIPMI.ENTITY_ID_IPMI_CHANNEL
ENTITY_ID_PCI_BUS = _OpenIPMI.ENTITY_ID_PCI_BUS
ENTITY_ID_PCI_EXPRESS_BUS = _OpenIPMI.ENTITY_ID_PCI_EXPRESS_BUS
ENTITY_ID_SCSI_BUS = _OpenIPMI.ENTITY_ID_SCSI_BUS
ENTITY_ID_SATA_SAS_BUS = _OpenIPMI.ENTITY_ID_SATA_SAS_BUS
ENTITY_ID_PROCESSOR_FRONT_SIDE_BUS = _OpenIPMI.ENTITY_ID_PROCESSOR_FRONT_SIDE_BUS

def fru_index_to_str(idx: 'int') -> "char *":
    return _OpenIPMI.fru_index_to_str(idx)
fru_index_to_str = _OpenIPMI.fru_index_to_str

def fru_str_to_index(name: 'char *') -> "int":
    return _OpenIPMI.fru_str_to_index(name)
fru_str_to_index = _OpenIPMI.fru_str_to_index

def alloc_cmdlang(handler: 'swig_cb *') -> "ipmi_cmdlang_t *":
    return _OpenIPMI.alloc_cmdlang(handler)
alloc_cmdlang = _OpenIPMI.alloc_cmdlang

def cmdlang_set_evinfo(evinfo: 'int') -> "void":
    return _OpenIPMI.cmdlang_set_evinfo(evinfo)
cmdlang_set_evinfo = _OpenIPMI.cmdlang_set_evinfo

def cmdlang_get_evinfo() -> "int":
    return _OpenIPMI.cmdlang_get_evinfo()
cmdlang_get_evinfo = _OpenIPMI.cmdlang_get_evinfo

def set_cmdlang_global_err_handler(handler: 'swig_cb *') -> "void":
    return _OpenIPMI.set_cmdlang_global_err_handler(handler)
set_cmdlang_global_err_handler = _OpenIPMI.set_cmdlang_global_err_handler

def set_cmdlang_event_handler(handler: 'swig_cb *') -> "void":
    return _OpenIPMI.set_cmdlang_event_handler(handler)
set_cmdlang_event_handler = _OpenIPMI.set_cmdlang_event_handler

def sol_state_string(val: 'int') -> "char *":
    return _OpenIPMI.sol_state_string(val)
sol_state_string = _OpenIPMI.sol_state_string
# This file is compatible with both classic and new-style classes.


