# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.1
#
# 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
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _OpenIPMI
else:
    import _OpenIPMI

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class strconstarray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    val = property(_OpenIPMI.strconstarray_val_get, _OpenIPMI.strconstarray_val_set)
    len = property(_OpenIPMI.strconstarray_len_get, _OpenIPMI.strconstarray_len_set)

    def __init__(self):
        _OpenIPMI.strconstarray_swiginit(self, _OpenIPMI.new_strconstarray())
    __swig_destroy__ = _OpenIPMI.delete_strconstarray

# Register strconstarray in _OpenIPMI:
_OpenIPMI.strconstarray_swigregister(strconstarray)
class argarray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    val = property(_OpenIPMI.argarray_val_get, _OpenIPMI.argarray_val_set)
    len = property(_OpenIPMI.argarray_len_get, _OpenIPMI.argarray_len_set)

    def __init__(self):
        _OpenIPMI.argarray_swiginit(self, _OpenIPMI.new_argarray())
    __swig_destroy__ = _OpenIPMI.delete_argarray

# Register argarray in _OpenIPMI:
_OpenIPMI.argarray_swigregister(argarray)
class iargarray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    val = property(_OpenIPMI.iargarray_val_get, _OpenIPMI.iargarray_val_set)
    len = property(_OpenIPMI.iargarray_len_get, _OpenIPMI.iargarray_len_set)

    def __init__(self):
        _OpenIPMI.iargarray_swiginit(self, _OpenIPMI.new_iargarray())
    __swig_destroy__ = _OpenIPMI.delete_iargarray

# Register iargarray in _OpenIPMI:
_OpenIPMI.iargarray_swigregister(iargarray)
class ipmi_domain_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_name(self):
        return _OpenIPMI.ipmi_domain_t_get_name(self)

    def get_id(self):
        return _OpenIPMI.ipmi_domain_t_get_id(self)

    def get_guid(self):
        return _OpenIPMI.ipmi_domain_t_get_guid(self)

    def close(self, handler):
        return _OpenIPMI.ipmi_domain_t_close(self, handler)

    def add_connect_change_handler(self, handler):
        return _OpenIPMI.ipmi_domain_t_add_connect_change_handler(self, handler)

    def remove_connect_change_handler(self, handler):
        return _OpenIPMI.ipmi_domain_t_remove_connect_change_handler(self, handler)

    def iterate_connections(self, handler):
        return _OpenIPMI.ipmi_domain_t_iterate_connections(self, handler)

    def activate_connection(self, connection):
        return _OpenIPMI.ipmi_domain_t_activate_connection(self, connection)

    def is_connection_active(self, connection, active):
        return _OpenIPMI.ipmi_domain_t_is_connection_active(self, connection, active)

    def is_connection_up(self, connection, up):
        return _OpenIPMI.ipmi_domain_t_is_connection_up(self, connection, up)

    def num_connection_ports(self, connection, ports):
        return _OpenIPMI.ipmi_domain_t_num_connection_ports(self, connection, ports)

    def is_connection_port_up(self, connection, port, up):
        return _OpenIPMI.ipmi_domain_t_is_connection_port_up(self, connection, port, up)

    def get_port_info(self, connection, port):
        return _OpenIPMI.ipmi_domain_t_get_port_info(self, connection, port)

    def get_connection_args(self, connection):
        return _OpenIPMI.ipmi_domain_t_get_connection_args(self, connection)

    def get_connection_type(self, connection):
        return _OpenIPMI.ipmi_domain_t_get_connection_type(self, connection)

    def add_entity_update_handler(self, handler):
        return _OpenIPMI.ipmi_domain_t_add_entity_update_handler(self, handler)

    def remove_entity_update_handler(self, handler):
        return _OpenIPMI.ipmi_domain_t_remove_entity_update_handler(self, handler)

    def iterate_entities(self, handler):
        return _OpenIPMI.ipmi_domain_t_iterate_entities(self, handler)

    def add_mc_update_handler(self, handler):
        return _OpenIPMI.ipmi_domain_t_add_mc_update_handler(self, handler)

    def remove_mc_update_handler(self, handler):
        return _OpenIPMI.ipmi_domain_t_remove_mc_update_handler(self, handler)

    def iterate_mcs(self, handler):
        return _OpenIPMI.ipmi_domain_t_iterate_mcs(self, handler)

    def get_type(self):
        return _OpenIPMI.ipmi_domain_t_get_type(self)

    def start_ipmb_mc_scan(self, channel, start_addr, end_addr, handler=None):
        return _OpenIPMI.ipmi_domain_t_start_ipmb_mc_scan(self, channel, start_addr, end_addr, handler)

    def start_full_ipmb_scan(self):
        return _OpenIPMI.ipmi_domain_t_start_full_ipmb_scan(self)

    def send_command_addr(self, addr, lun, netfn, cmd, msg_data, handler=None):
        return _OpenIPMI.ipmi_domain_t_send_command_addr(self, addr, lun, netfn, cmd, msg_data, handler)

    def detect_presence_changes(self, force=0):
        return _OpenIPMI.ipmi_domain_t_detect_presence_changes(self, force)

    def set_sel_rescan_time(self, seconds):
        return _OpenIPMI.ipmi_domain_t_set_sel_rescan_time(self, seconds)

    def get_sel_rescan_time(self):
        return _OpenIPMI.ipmi_domain_t_get_sel_rescan_time(self)

    def set_ipmb_rescan_time(self, seconds):
        return _OpenIPMI.ipmi_domain_t_set_ipmb_rescan_time(self, seconds)

    def get_ipmb_rescan_time(self):
        return _OpenIPMI.ipmi_domain_t_get_ipmb_rescan_time(self)

    def add_event_handler(self, handler):
        return _OpenIPMI.ipmi_domain_t_add_event_handler(self, handler)

    def remove_event_handler(self, handler):
        return _OpenIPMI.ipmi_domain_t_remove_event_handler(self, handler)

    def first_event(self):
        return _OpenIPMI.ipmi_domain_t_first_event(self)

    def last_event(self):
        return _OpenIPMI.ipmi_domain_t_last_event(self)

    def next_event(self, event):
        return _OpenIPMI.ipmi_domain_t_next_event(self, event)

    def prev_event(self, event):
        return _OpenIPMI.ipmi_domain_t_prev_event(self, event)

    def sel_count(self):
        return _OpenIPMI.ipmi_domain_t_sel_count(self)

    def sel_entries_used(self):
        return _OpenIPMI.ipmi_domain_t_sel_entries_used(self)

    def reread_sels(self, handler=None):
        return _OpenIPMI.ipmi_domain_t_reread_sels(self, handler)

    def fru_alloc(self, is_logical, device_address, device_id, lun, private_bus, channel, handler=None):
        return _OpenIPMI.ipmi_domain_t_fru_alloc(self, is_logical, device_address, device_id, lun, private_bus, channel, handler)

    def get_pet(self, connection, channel, ip_addr, mac_addr, eft_sel, policy_num, apt_sel, lan_dest_sel, handler=None):
        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, handler):
        return _OpenIPMI.ipmi_domain_t_create_sol(self, connection, handler)

# Register ipmi_domain_t in _OpenIPMI:
_OpenIPMI.ipmi_domain_t_swigregister(ipmi_domain_t)
class ipmi_domain_id_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def cmp(self, other):
        return _OpenIPMI.ipmi_domain_id_t_cmp(self, other)

    def to_domain(self, handler):
        return _OpenIPMI.ipmi_domain_id_t_to_domain(self, handler)

# Register ipmi_domain_id_t in _OpenIPMI:
_OpenIPMI.ipmi_domain_id_t_swigregister(ipmi_domain_id_t)
class ipmi_args_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_type(self):
        return _OpenIPMI.ipmi_args_t_get_type(self)

    def get_val(self, argnum, name, type, help, value, range):
        return _OpenIPMI.ipmi_args_t_get_val(self, argnum, name, type, help, value, range)

    def set_val(self, argnum, name, value):
        return _OpenIPMI.ipmi_args_t_set_val(self, argnum, name, value)

# Register ipmi_args_t in _OpenIPMI:
_OpenIPMI.ipmi_args_t_swigregister(ipmi_args_t)
class ipmi_entity_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_domain(self):
        return _OpenIPMI.ipmi_entity_t_get_domain(self)

    def get_name(self):
        return _OpenIPMI.ipmi_entity_t_get_name(self)

    def get_id(self):
        return _OpenIPMI.ipmi_entity_t_get_id(self)

    def iterate_children(self, handler):
        return _OpenIPMI.ipmi_entity_t_iterate_children(self, handler)

    def iterate_parents(self, handler):
        return _OpenIPMI.ipmi_entity_t_iterate_parents(self, handler)

    def iterate_sensors(self, handler):
        return _OpenIPMI.ipmi_entity_t_iterate_sensors(self, handler)

    def iterate_controls(self, handler):
        return _OpenIPMI.ipmi_entity_t_iterate_controls(self, handler)

    def add_presence_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_add_presence_handler(self, handler)

    def remove_presence_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_remove_presence_handler(self, handler)

    def add_sensor_update_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_add_sensor_update_handler(self, handler)

    def remove_sensor_update_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_remove_sensor_update_handler(self, handler)

    def add_control_update_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_add_control_update_handler(self, handler)

    def remove_control_update_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_remove_control_update_handler(self, handler)

    def add_fru_update_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_add_fru_update_handler(self, handler)

    def remove_fru_update_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_remove_fru_update_handler(self, handler)

    def add_fru_update_werr_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_add_fru_update_werr_handler(self, handler)

    def remove_fru_update_werr_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_remove_fru_update_werr_handler(self, handler)

    def get_type(self):
        return _OpenIPMI.ipmi_entity_t_get_type(self)

    def is_fru(self):
        return _OpenIPMI.ipmi_entity_t_is_fru(self)

    def get_id_string(self):
        return _OpenIPMI.ipmi_entity_t_get_id_string(self)

    def get_entity_id(self):
        return _OpenIPMI.ipmi_entity_t_get_entity_id(self)

    def get_entity_id_string(self):
        return _OpenIPMI.ipmi_entity_t_get_entity_id_string(self)

    def get_entity_instance(self):
        return _OpenIPMI.ipmi_entity_t_get_entity_instance(self)

    def get_entity_device_channel(self):
        return _OpenIPMI.ipmi_entity_t_get_entity_device_channel(self)

    def get_entity_device_address(self):
        return _OpenIPMI.ipmi_entity_t_get_entity_device_address(self)

    def get_fru(self):
        return _OpenIPMI.ipmi_entity_t_get_fru(self)

    def get_presence_sensor_always_there(self):
        return _OpenIPMI.ipmi_entity_t_get_presence_sensor_always_there(self)

    def is_child(self):
        return _OpenIPMI.ipmi_entity_t_is_child(self)

    def is_parent(self):
        return _OpenIPMI.ipmi_entity_t_is_parent(self)

    def get_channel(self):
        return _OpenIPMI.ipmi_entity_t_get_channel(self)

    def get_lun(self):
        return _OpenIPMI.ipmi_entity_t_get_lun(self)

    def get_oem(self):
        return _OpenIPMI.ipmi_entity_t_get_oem(self)

    def get_access_address(self):
        return _OpenIPMI.ipmi_entity_t_get_access_address(self)

    def get_private_bus_id(self):
        return _OpenIPMI.ipmi_entity_t_get_private_bus_id(self)

    def get_device_type(self):
        return _OpenIPMI.ipmi_entity_t_get_device_type(self)

    def get_device_modifier(self):
        return _OpenIPMI.ipmi_entity_t_get_device_modifier(self)

    def get_slave_address(self):
        return _OpenIPMI.ipmi_entity_t_get_slave_address(self)

    def get_mc_id(self):
        return _OpenIPMI.ipmi_entity_t_get_mc_id(self)

    def get_is_logical_fru(self):
        return _OpenIPMI.ipmi_entity_t_get_is_logical_fru(self)

    def get_fru_device_id(self):
        return _OpenIPMI.ipmi_entity_t_get_fru_device_id(self)

    def get_ACPI_system_power_notify_required(self):
        return _OpenIPMI.ipmi_entity_t_get_ACPI_system_power_notify_required(self)

    def get_ACPI_device_power_notify_required(self):
        return _OpenIPMI.ipmi_entity_t_get_ACPI_device_power_notify_required(self)

    def get_controller_logs_init_agent_errors(self):
        return _OpenIPMI.ipmi_entity_t_get_controller_logs_init_agent_errors(self)

    def get_log_init_agent_errors_accessing(self):
        return _OpenIPMI.ipmi_entity_t_get_log_init_agent_errors_accessing(self)

    def get_global_init(self):
        return _OpenIPMI.ipmi_entity_t_get_global_init(self)

    def get_chassis_device(self):
        return _OpenIPMI.ipmi_entity_t_get_chassis_device(self)

    def get_bridge(self):
        return _OpenIPMI.ipmi_entity_t_get_bridge(self)

    def get_IPMB_event_generator(self):
        return _OpenIPMI.ipmi_entity_t_get_IPMB_event_generator(self)

    def get_IPMB_event_receiver(self):
        return _OpenIPMI.ipmi_entity_t_get_IPMB_event_receiver(self)

    def get_FRU_inventory_device(self):
        return _OpenIPMI.ipmi_entity_t_get_FRU_inventory_device(self)

    def get_SEL_device(self):
        return _OpenIPMI.ipmi_entity_t_get_SEL_device(self)

    def get_SDR_repository_device(self):
        return _OpenIPMI.ipmi_entity_t_get_SDR_repository_device(self)

    def get_sensor_device(self):
        return _OpenIPMI.ipmi_entity_t_get_sensor_device(self)

    def get_address_span(self):
        return _OpenIPMI.ipmi_entity_t_get_address_span(self)

    def get_dlr_id(self):
        return _OpenIPMI.ipmi_entity_t_get_dlr_id(self)

    def is_present(self):
        return _OpenIPMI.ipmi_entity_t_is_present(self)

    def get_physical_slot_num(self):
        return _OpenIPMI.ipmi_entity_t_get_physical_slot_num(self)

    def is_hot_swappable(self):
        return _OpenIPMI.ipmi_entity_t_is_hot_swappable(self)

    def supports_managed_hot_swap(self):
        return _OpenIPMI.ipmi_entity_t_supports_managed_hot_swap(self)

    def add_hot_swap_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_add_hot_swap_handler(self, handler)

    def remove_hot_swap_handler(self, handler):
        return _OpenIPMI.ipmi_entity_t_remove_hot_swap_handler(self, handler)

    def get_hot_swap_state(self, handler):
        return _OpenIPMI.ipmi_entity_t_get_hot_swap_state(self, handler)

    def supports_auto_activate_time(self):
        return _OpenIPMI.ipmi_entity_t_supports_auto_activate_time(self)

    def get_auto_activate_time(self, handler):
        return _OpenIPMI.ipmi_entity_t_get_auto_activate_time(self, handler)

    def set_auto_activate_time(self, auto_act, handler=None):
        return _OpenIPMI.ipmi_entity_t_set_auto_activate_time(self, auto_act, handler)

    def supports_auto_deactivate_time(self):
        return _OpenIPMI.ipmi_entity_t_supports_auto_deactivate_time(self)

    def get_auto_deactivate_time(self, handler):
        return _OpenIPMI.ipmi_entity_t_get_auto_deactivate_time(self, handler)

    def set_auto_deactivate_time(self, auto_act, handler=None):
        return _OpenIPMI.ipmi_entity_t_set_auto_deactivate_time(self, auto_act, handler)

    def set_activation_requested(self, handler=None):
        return _OpenIPMI.ipmi_entity_t_set_activation_requested(self, handler)

    def activate(self, handler=None):
        return _OpenIPMI.ipmi_entity_t_activate(self, handler)

    def deactivate(self, handler=None):
        return _OpenIPMI.ipmi_entity_t_deactivate(self, handler)

    def check_hot_swap_state(self):
        return _OpenIPMI.ipmi_entity_t_check_hot_swap_state(self)

# Register ipmi_entity_t in _OpenIPMI:
_OpenIPMI.ipmi_entity_t_swigregister(ipmi_entity_t)
class ipmi_entity_id_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def cmp(self, other):
        return _OpenIPMI.ipmi_entity_id_t_cmp(self, other)

    def to_entity(self, handler):
        return _OpenIPMI.ipmi_entity_id_t_to_entity(self, handler)

# Register ipmi_entity_id_t in _OpenIPMI:
_OpenIPMI.ipmi_entity_id_t_swigregister(ipmi_entity_id_t)
class ipmi_fru_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_domain_id(self):
        return _OpenIPMI.ipmi_fru_t_get_domain_id(self)

    def str_to_index(self, name):
        return _OpenIPMI.ipmi_fru_t_str_to_index(self, name)

    def get(self, index, num):
        return _OpenIPMI.ipmi_fru_t_get(self, index, num)

    def get_num_multi_records(self):
        return _OpenIPMI.ipmi_fru_t_get_num_multi_records(self)

    def get_multirecord(self, num):
        return _OpenIPMI.ipmi_fru_t_get_multirecord(self, num)

    def set(self, index, num, type, value=None):
        return _OpenIPMI.ipmi_fru_t_set(self, index, num, type, value)

    def set_array(self, index, num, type, value):
        return _OpenIPMI.ipmi_fru_t_set_array(self, index, num, type, value)

    def set_multirecord(self, num, type, version, value=None):
        return _OpenIPMI.ipmi_fru_t_set_multirecord(self, num, type, version, value)

    def set_multirecord_array(self, num, type, version, value):
        return _OpenIPMI.ipmi_fru_t_set_multirecord_array(self, num, type, version, value)

    def add_area(self, area, offset, length):
        return _OpenIPMI.ipmi_fru_t_add_area(self, area, offset, length)

    def delete_area(self, area):
        return _OpenIPMI.ipmi_fru_t_delete_area(self, area)

    def area_get_offset(self, area, offset):
        return _OpenIPMI.ipmi_fru_t_area_get_offset(self, area, offset)

    def area_get_length(self, area, length):
        return _OpenIPMI.ipmi_fru_t_area_get_length(self, area, length)

    def area_set_offset(self, area, offset):
        return _OpenIPMI.ipmi_fru_t_area_set_offset(self, area, offset)

    def area_set_length(self, area, length):
        return _OpenIPMI.ipmi_fru_t_area_set_length(self, area, length)

    def area_get_used_length(self, area, used_length):
        return _OpenIPMI.ipmi_fru_t_area_get_used_length(self, area, used_length)

    def write(self, handler=None):
        return _OpenIPMI.ipmi_fru_t_write(self, handler)

    def multi_record_get_root_node(self, record_num, name, sub_node):
        return _OpenIPMI.ipmi_fru_t_multi_record_get_root_node(self, record_num, name, sub_node)

    def get_root_node(self, type, sub_node):
        return _OpenIPMI.ipmi_fru_t_get_root_node(self, type, sub_node)

# Register ipmi_fru_t in _OpenIPMI:
_OpenIPMI.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_field(self, index, name, type, value, sub_node):
        return _OpenIPMI.ipmi_fru_node_t_get_field(self, index, name, type, value, sub_node)

    def get_enum_val(self, index, pos, nextpos, data):
        return _OpenIPMI.ipmi_fru_node_t_get_enum_val(self, index, pos, nextpos, data)

    def set_field(self, index, type, value):
        return _OpenIPMI.ipmi_fru_node_t_set_field(self, index, type, value)

    def settable(self, index):
        return _OpenIPMI.ipmi_fru_node_t_settable(self, index)

    def get_subtype(self):
        return _OpenIPMI.ipmi_fru_node_t_get_subtype(self)

# Register ipmi_fru_node_t in _OpenIPMI:
_OpenIPMI.ipmi_fru_node_t_swigregister(ipmi_fru_node_t)
class ipmi_mc_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_domain(self):
        return _OpenIPMI.ipmi_mc_t_get_domain(self)

    def get_name(self):
        return _OpenIPMI.ipmi_mc_t_get_name(self)

    def get_id(self):
        return _OpenIPMI.ipmi_mc_t_get_id(self)

    def get_guid(self):
        return _OpenIPMI.ipmi_mc_t_get_guid(self)

    def provides_device_sdrs(self):
        return _OpenIPMI.ipmi_mc_t_provides_device_sdrs(self)

    def device_available(self):
        return _OpenIPMI.ipmi_mc_t_device_available(self)

    def chassis_support(self):
        return _OpenIPMI.ipmi_mc_t_chassis_support(self)

    def bridge_support(self):
        return _OpenIPMI.ipmi_mc_t_bridge_support(self)

    def ipmb_event_generator_support(self):
        return _OpenIPMI.ipmi_mc_t_ipmb_event_generator_support(self)

    def ipmb_event_receiver_support(self):
        return _OpenIPMI.ipmi_mc_t_ipmb_event_receiver_support(self)

    def fru_inventory_support(self):
        return _OpenIPMI.ipmi_mc_t_fru_inventory_support(self)

    def sel_device_support(self):
        return _OpenIPMI.ipmi_mc_t_sel_device_support(self)

    def sdr_repository_support(self):
        return _OpenIPMI.ipmi_mc_t_sdr_repository_support(self)

    def sensor_device_support(self):
        return _OpenIPMI.ipmi_mc_t_sensor_device_support(self)

    def device_id(self):
        return _OpenIPMI.ipmi_mc_t_device_id(self)

    def device_revision(self):
        return _OpenIPMI.ipmi_mc_t_device_revision(self)

    def major_fw_revision(self):
        return _OpenIPMI.ipmi_mc_t_major_fw_revision(self)

    def minor_fw_revision(self):
        return _OpenIPMI.ipmi_mc_t_minor_fw_revision(self)

    def major_version(self):
        return _OpenIPMI.ipmi_mc_t_major_version(self)

    def minor_version(self):
        return _OpenIPMI.ipmi_mc_t_minor_version(self)

    def manufacturer_id(self):
        return _OpenIPMI.ipmi_mc_t_manufacturer_id(self)

    def product_id(self):
        return _OpenIPMI.ipmi_mc_t_product_id(self)

    def aux_fw_revision(self):
        return _OpenIPMI.ipmi_mc_t_aux_fw_revision(self)

    def is_active(self):
        return _OpenIPMI.ipmi_mc_t_is_active(self)

    def add_active_handler(self, handler):
        return _OpenIPMI.ipmi_mc_t_add_active_handler(self, handler)

    def remove_active_handler(self, handler):
        return _OpenIPMI.ipmi_mc_t_remove_active_handler(self, handler)

    def add_fully_up_handler(self, handler):
        return _OpenIPMI.ipmi_mc_t_add_fully_up_handler(self, handler)

    def remove_fully_up_handler(self, handler):
        return _OpenIPMI.ipmi_mc_t_remove_fully_up_handler(self, handler)

    def send_command(self, lun, netfn, cmd, msg_data, handler=None):
        return _OpenIPMI.ipmi_mc_t_send_command(self, lun, netfn, cmd, msg_data, handler)

    def reset(self, reset_type, handler=None):
        return _OpenIPMI.ipmi_mc_t_reset(self, reset_type, handler)

    def get_events_enable(self):
        return _OpenIPMI.ipmi_mc_t_get_events_enable(self)

    def set_events_enable(self, val, handler=None):
        return _OpenIPMI.ipmi_mc_t_set_events_enable(self, val, handler)

    def get_event_log_enable(self, handler):
        return _OpenIPMI.ipmi_mc_t_get_event_log_enable(self, handler)

    def set_event_log_enable(self, val, handler=None):
        return _OpenIPMI.ipmi_mc_t_set_event_log_enable(self, val, handler)

    def reread_sensors(self, handler=None):
        return _OpenIPMI.ipmi_mc_t_reread_sensors(self, handler)

    def set_sel_rescan_time(self, seconds):
        return _OpenIPMI.ipmi_mc_t_set_sel_rescan_time(self, seconds)

    def get_sel_rescan_time(self):
        return _OpenIPMI.ipmi_mc_t_get_sel_rescan_time(self)

    def reread_sel(self, handler=None):
        return _OpenIPMI.ipmi_mc_t_reread_sel(self, handler)

    def get_current_sel_time(self, handler):
        return _OpenIPMI.ipmi_mc_t_get_current_sel_time(self, handler)

    def first_event(self):
        return _OpenIPMI.ipmi_mc_t_first_event(self)

    def last_event(self):
        return _OpenIPMI.ipmi_mc_t_last_event(self)

    def next_event(self, event):
        return _OpenIPMI.ipmi_mc_t_next_event(self, event)

    def prev_event(self, event):
        return _OpenIPMI.ipmi_mc_t_prev_event(self, event)

    def event_by_recid(self, record_id):
        return _OpenIPMI.ipmi_mc_t_event_by_recid(self, record_id)

    def sel_count(self):
        return _OpenIPMI.ipmi_mc_t_sel_count(self)

    def sel_entries_used(self):
        return _OpenIPMI.ipmi_mc_t_sel_entries_used(self)

    def sel_get_major_version(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_major_version(self)

    def sel_get_minor_version(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_minor_version(self)

    def sel_get_num_entries(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_num_entries(self)

    def sel_get_free_bytes(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_free_bytes(self)

    def sel_get_overflow(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_overflow(self)

    def sel_get_supports_delete_sel(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_supports_delete_sel(self)

    def sel_get_supports_partial_add_sel(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_supports_partial_add_sel(self)

    def sel_get_supports_reserve_sel(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_supports_reserve_sel(self)

    def sel_get_supports_get_sel_allocation(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_supports_get_sel_allocation(self)

    def sel_get_last_addition_timestamp(self):
        return _OpenIPMI.ipmi_mc_t_sel_get_last_addition_timestamp(self)

    def channel_get_info(self, channel, handler):
        return _OpenIPMI.ipmi_mc_t_channel_get_info(self, channel, handler)

    def channel_get_access(self, channel, type, handler):
        return _OpenIPMI.ipmi_mc_t_channel_get_access(self, channel, type, handler)

    def channel_set_access(self, access, channel, type, handler=None):
        return _OpenIPMI.ipmi_mc_t_channel_set_access(self, access, channel, type, handler)

    def get_users(self, channel, user, handler):
        return _OpenIPMI.ipmi_mc_t_get_users(self, channel, user, handler)

    def set_user(self, userinfo, channel, usernum, handler=None):
        return _OpenIPMI.ipmi_mc_t_set_user(self, userinfo, channel, usernum, handler)

    def get_lanparm(self, channel):
        return _OpenIPMI.ipmi_mc_t_get_lanparm(self, channel)

    def get_pef(self, handler=None):
        return _OpenIPMI.ipmi_mc_t_get_pef(self, handler)

    def get_pet(self, channel, ip_addr, mac_addr, eft_sel, policy_num, apt_sel, lan_dest_sel, handler=None):
        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):
        return _OpenIPMI.ipmi_mc_t_get_solparm(self, channel)

# Register ipmi_mc_t in _OpenIPMI:
_OpenIPMI.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def cmp(self, other):
        return _OpenIPMI.ipmi_mcid_t_cmp(self, other)

    def to_mc(self, handler):
        return _OpenIPMI.ipmi_mcid_t_to_mc(self, handler)

# Register ipmi_mcid_t in _OpenIPMI:
_OpenIPMI.ipmi_mcid_t_swigregister(ipmi_mcid_t)
class ipmi_event_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def delete(self, handler=None):
        return _OpenIPMI.ipmi_event_t_delete(self, handler)

    def get_mc_id(self):
        return _OpenIPMI.ipmi_event_t_get_mc_id(self)

    def get_record_id(self):
        return _OpenIPMI.ipmi_event_t_get_record_id(self)

    def get_type(self):
        return _OpenIPMI.ipmi_event_t_get_type(self)

    def get_timestamp(self):
        return _OpenIPMI.ipmi_event_t_get_timestamp(self)

    def get_data(self):
        return _OpenIPMI.ipmi_event_t_get_data(self)

    def call_handler(self, handler):
        return _OpenIPMI.ipmi_event_t_call_handler(self, handler)

# Register ipmi_event_t in _OpenIPMI:
_OpenIPMI.ipmi_event_t_swigregister(ipmi_event_t)
class ipmi_sensor_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_name(self):
        return _OpenIPMI.ipmi_sensor_t_get_name(self)

    def get_id(self):
        return _OpenIPMI.ipmi_sensor_t_get_id(self)

    def add_event_handler(self, handler):
        return _OpenIPMI.ipmi_sensor_t_add_event_handler(self, handler)

    def remove_event_handler(self, handler):
        return _OpenIPMI.ipmi_sensor_t_remove_event_handler(self, handler)

    def set_event_enables(self, states, handler=None):
        return _OpenIPMI.ipmi_sensor_t_set_event_enables(self, states, handler)

    def enable_events(self, states, handler=None):
        return _OpenIPMI.ipmi_sensor_t_enable_events(self, states, handler)

    def disable_events(self, states, handler=None):
        return _OpenIPMI.ipmi_sensor_t_disable_events(self, states, handler)

    def get_event_enables(self, handler):
        return _OpenIPMI.ipmi_sensor_t_get_event_enables(self, handler)

    def rearm(self, global_enable, states, handler=None):
        return _OpenIPMI.ipmi_sensor_t_rearm(self, global_enable, states, handler)

    def get_hysteresis(self, handler):
        return _OpenIPMI.ipmi_sensor_t_get_hysteresis(self, handler)

    def set_hysteresis(self, positive_hysteresis, negative_hysteresis, handler=None):
        return _OpenIPMI.ipmi_sensor_t_set_hysteresis(self, positive_hysteresis, negative_hysteresis, handler)

    def get_default_thresholds(self):
        return _OpenIPMI.ipmi_sensor_t_get_default_thresholds(self)

    def set_thresholds(self, thresholds, handler=None):
        return _OpenIPMI.ipmi_sensor_t_set_thresholds(self, thresholds, handler)

    def get_thresholds(self, handler):
        return _OpenIPMI.ipmi_sensor_t_get_thresholds(self, handler)

    def get_value(self, handler):
        return _OpenIPMI.ipmi_sensor_t_get_value(self, handler)

    def get_lun(self):
        return _OpenIPMI.ipmi_sensor_t_get_lun(self)

    def get_num(self):
        return _OpenIPMI.ipmi_sensor_t_get_num(self)

    def get_sensor_type_string(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_type_string(self)

    def get_sensor_type(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_type(self)

    def get_event_reading_type_string(self):
        return _OpenIPMI.ipmi_sensor_t_get_event_reading_type_string(self)

    def get_event_reading_type(self):
        return _OpenIPMI.ipmi_sensor_t_get_event_reading_type(self)

    def get_rate_unit_string(self):
        return _OpenIPMI.ipmi_sensor_t_get_rate_unit_string(self)

    def get_rate_unit(self):
        return _OpenIPMI.ipmi_sensor_t_get_rate_unit(self)

    def get_base_unit_string(self):
        return _OpenIPMI.ipmi_sensor_t_get_base_unit_string(self)

    def get_base_unit(self):
        return _OpenIPMI.ipmi_sensor_t_get_base_unit(self)

    def get_modifier_unit_string(self):
        return _OpenIPMI.ipmi_sensor_t_get_modifier_unit_string(self)

    def get_modifier_unit(self):
        return _OpenIPMI.ipmi_sensor_t_get_modifier_unit(self)

    def get_modifier_unit_use(self):
        return _OpenIPMI.ipmi_sensor_t_get_modifier_unit_use(self)

    def get_percentage(self):
        return _OpenIPMI.ipmi_sensor_t_get_percentage(self)

    def reading_name_string(self, offset):
        return _OpenIPMI.ipmi_sensor_t_reading_name_string(self, offset)

    def get_entity_id(self):
        return _OpenIPMI.ipmi_sensor_t_get_entity_id(self)

    def get_entity_instance(self):
        return _OpenIPMI.ipmi_sensor_t_get_entity_instance(self)

    def get_entity(self):
        return _OpenIPMI.ipmi_sensor_t_get_entity(self)

    def get_sensor_init_scanning(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_scanning(self)

    def get_sensor_init_events(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_events(self)

    def get_sensor_init_thresholds(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_thresholds(self)

    def get_sensor_init_hysteresis(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_hysteresis(self)

    def get_sensor_init_type(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_type(self)

    def get_sensor_init_pu_events(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_pu_events(self)

    def get_sensor_init_pu_scanning(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_init_pu_scanning(self)

    def get_ignore_if_no_entity(self):
        return _OpenIPMI.ipmi_sensor_t_get_ignore_if_no_entity(self)

    def get_supports_auto_rearm(self):
        return _OpenIPMI.ipmi_sensor_t_get_supports_auto_rearm(self)

    def get_threshold_access(self):
        return _OpenIPMI.ipmi_sensor_t_get_threshold_access(self)

    def get_hysteresis_support(self):
        return _OpenIPMI.ipmi_sensor_t_get_hysteresis_support(self)

    def get_event_support(self):
        return _OpenIPMI.ipmi_sensor_t_get_event_support(self)

    def get_sensor_direction(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_direction(self)

    def is_readable(self):
        return _OpenIPMI.ipmi_sensor_t_is_readable(self)

    def threshold_event_supported(self, event, val):
        return _OpenIPMI.ipmi_sensor_t_threshold_event_supported(self, event, val)

    def threshold_settable(self, threshold, val):
        return _OpenIPMI.ipmi_sensor_t_threshold_settable(self, threshold, val)

    def threshold_readable(self, threshold, val):
        return _OpenIPMI.ipmi_sensor_t_threshold_readable(self, threshold, val)

    def threshold_reading_supported(self, threshold, val):
        return _OpenIPMI.ipmi_sensor_t_threshold_reading_supported(self, threshold, val)

    def discrete_event_supported(self, event, val):
        return _OpenIPMI.ipmi_sensor_t_discrete_event_supported(self, event, val)

    def discrete_event_readable(self, offset, val):
        return _OpenIPMI.ipmi_sensor_t_discrete_event_readable(self, offset, val)

    def get_tolerance(self, val, tolerance):
        return _OpenIPMI.ipmi_sensor_t_get_tolerance(self, val, tolerance)

    def get_accuracy(self, val, accuracy):
        return _OpenIPMI.ipmi_sensor_t_get_accuracy(self, val, accuracy)

    def get_normal_min_specified(self):
        return _OpenIPMI.ipmi_sensor_t_get_normal_min_specified(self)

    def get_normal_min(self, normal_min):
        return _OpenIPMI.ipmi_sensor_t_get_normal_min(self, normal_min)

    def get_normal_max_specified(self):
        return _OpenIPMI.ipmi_sensor_t_get_normal_max_specified(self)

    def get_normal_max(self, normal_max):
        return _OpenIPMI.ipmi_sensor_t_get_normal_max(self, normal_max)

    def get_nominal_reading_specified(self):
        return _OpenIPMI.ipmi_sensor_t_get_nominal_reading_specified(self)

    def get_nominal_reading(self, nominal_reading):
        return _OpenIPMI.ipmi_sensor_t_get_nominal_reading(self, nominal_reading)

    def get_sensor_max(self, sensor_max):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_max(self, sensor_max)

    def get_sensor_min(self, sensor_min):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_min(self, sensor_min)

    def get_oem1(self):
        return _OpenIPMI.ipmi_sensor_t_get_oem1(self)

    def get_sensor_id(self):
        return _OpenIPMI.ipmi_sensor_t_get_sensor_id(self)

    def get_mc(self):
        return _OpenIPMI.ipmi_sensor_t_get_mc(self)

# Register ipmi_sensor_t in _OpenIPMI:
_OpenIPMI.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_GLOBAL_DISABLE = _OpenIPMI.EVENT_SUPPORT_GLOBAL_DISABLE
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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def cmp(self, other):
        return _OpenIPMI.ipmi_sensor_id_t_cmp(self, other)

    def to_sensor(self, handler):
        return _OpenIPMI.ipmi_sensor_id_t_to_sensor(self, handler)

# Register ipmi_sensor_id_t in _OpenIPMI:
_OpenIPMI.ipmi_sensor_id_t_swigregister(ipmi_sensor_id_t)
class ipmi_control_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_name(self):
        return _OpenIPMI.ipmi_control_t_get_name(self)

    def get_id(self):
        return _OpenIPMI.ipmi_control_t_get_id(self)

    def get_type_string(self):
        return _OpenIPMI.ipmi_control_t_get_type_string(self)

    def get_type(self):
        return _OpenIPMI.ipmi_control_t_get_type(self)

    def get_entity_id(self):
        return _OpenIPMI.ipmi_control_t_get_entity_id(self)

    def get_entity_instance(self):
        return _OpenIPMI.ipmi_control_t_get_entity_instance(self)

    def get_entity(self):
        return _OpenIPMI.ipmi_control_t_get_entity(self)

    def is_settable(self):
        return _OpenIPMI.ipmi_control_t_is_settable(self)

    def is_readable(self):
        return _OpenIPMI.ipmi_control_t_is_readable(self)

    def get_ignore_if_no_entity(self):
        return _OpenIPMI.ipmi_control_t_get_ignore_if_no_entity(self)

    def get_control_id(self):
        return _OpenIPMI.ipmi_control_t_get_control_id(self)

    def has_events(self):
        return _OpenIPMI.ipmi_control_t_has_events(self)

    def get_num_vals(self):
        return _OpenIPMI.ipmi_control_t_get_num_vals(self)

    def set_val(self, val, handler=None):
        return _OpenIPMI.ipmi_control_t_set_val(self, val, handler)

    def get_val(self, handler):
        return _OpenIPMI.ipmi_control_t_get_val(self, handler)

    def add_event_handler(self, handler):
        return _OpenIPMI.ipmi_control_t_add_event_handler(self, handler)

    def remove_event_handler(self, handler):
        return _OpenIPMI.ipmi_control_t_remove_event_handler(self, handler)

    def light_set_with_setting(self):
        return _OpenIPMI.ipmi_control_t_light_set_with_setting(self)

    def light_is_color_supported(self, light_num, color):
        return _OpenIPMI.ipmi_control_t_light_is_color_supported(self, light_num, color)

    def light_has_local_control(self, light_num):
        return _OpenIPMI.ipmi_control_t_light_has_local_control(self, light_num)

    def set_light(self, settings, handler=None):
        return _OpenIPMI.ipmi_control_t_set_light(self, settings, handler)

    def get_light(self, handler):
        return _OpenIPMI.ipmi_control_t_get_light(self, handler)

    def get_num_light_values(self, light):
        return _OpenIPMI.ipmi_control_t_get_num_light_values(self, light)

    def get_num_light_transitions(self, light, value):
        return _OpenIPMI.ipmi_control_t_get_num_light_transitions(self, light, value)

    def get_light_color(self, light, value, transition):
        return _OpenIPMI.ipmi_control_t_get_light_color(self, light, value, transition)

    def get_light_color_time(self, light, value, transition):
        return _OpenIPMI.ipmi_control_t_get_light_color_time(self, light, value, transition)

    def identifier_set_val(self, val, handler=None):
        return _OpenIPMI.ipmi_control_t_identifier_set_val(self, val, handler)

    def identifier_get_val(self, handler):
        return _OpenIPMI.ipmi_control_t_identifier_get_val(self, handler)

    def identifier_get_max_length(self):
        return _OpenIPMI.ipmi_control_t_identifier_get_max_length(self)

# Register ipmi_control_t in _OpenIPMI:
_OpenIPMI.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def cmp(self, other):
        return _OpenIPMI.ipmi_control_id_t_cmp(self, other)

    def to_control(self, handler):
        return _OpenIPMI.ipmi_control_id_t_to_control(self, handler)

# Register ipmi_control_id_t in _OpenIPMI:
_OpenIPMI.ipmi_control_id_t_swigregister(ipmi_control_id_t)
class ipmi_channel_info_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def copy(self):
        return _OpenIPMI.ipmi_channel_info_t_copy(self)

    def get_channel(self, channel):
        return _OpenIPMI.ipmi_channel_info_t_get_channel(self, channel)

    def get_medium(self, medium):
        return _OpenIPMI.ipmi_channel_info_t_get_medium(self, medium)

    def get_protocol_type(self, prot_type):
        return _OpenIPMI.ipmi_channel_info_t_get_protocol_type(self, prot_type)

    def get_session_support(self, sup):
        return _OpenIPMI.ipmi_channel_info_t_get_session_support(self, sup)

    def get_vendor_id(self):
        return _OpenIPMI.ipmi_channel_info_t_get_vendor_id(self)

    def get_aux_info(self):
        return _OpenIPMI.ipmi_channel_info_t_get_aux_info(self)

# Register ipmi_channel_info_t in _OpenIPMI:
_OpenIPMI.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def copy(self):
        return _OpenIPMI.ipmi_channel_access_t_copy(self)

    def get_channel(self, channel):
        return _OpenIPMI.ipmi_channel_access_t_get_channel(self, channel)

    def get_alerting_enabled(self, enab):
        return _OpenIPMI.ipmi_channel_access_t_get_alerting_enabled(self, enab)

    def set_alerting_enabled(self, enab):
        return _OpenIPMI.ipmi_channel_access_t_set_alerting_enabled(self, enab)

    def get_per_msg_auth(self, msg_auth):
        return _OpenIPMI.ipmi_channel_access_t_get_per_msg_auth(self, msg_auth)

    def set_per_msg_auth(self, msg_auth):
        return _OpenIPMI.ipmi_channel_access_t_set_per_msg_auth(self, msg_auth)

    def get_user_auth(self, user_auth):
        return _OpenIPMI.ipmi_channel_access_t_get_user_auth(self, user_auth)

    def set_user_auth(self, user_auth):
        return _OpenIPMI.ipmi_channel_access_t_set_user_auth(self, user_auth)

    def get_access_mode(self, access_mode):
        return _OpenIPMI.ipmi_channel_access_t_get_access_mode(self, access_mode)

    def set_access_mode(self, access_mode):
        return _OpenIPMI.ipmi_channel_access_t_set_access_mode(self, access_mode)

    def get_privilege_limit(self, priv_limit):
        return _OpenIPMI.ipmi_channel_access_t_get_privilege_limit(self, priv_limit)

    def set_privilege_limit(self, priv_limit):
        return _OpenIPMI.ipmi_channel_access_t_set_privilege_limit(self, priv_limit)

    def setall(self):
        return _OpenIPMI.ipmi_channel_access_t_setall(self)

# Register ipmi_channel_access_t in _OpenIPMI:
_OpenIPMI.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def copy(self):
        return _OpenIPMI.ipmi_user_t_copy(self)

    def get_channel(self, channel):
        return _OpenIPMI.ipmi_user_t_get_channel(self, channel)

    def get_num(self, num):
        return _OpenIPMI.ipmi_user_t_get_num(self, num)

    def set_num(self, num):
        return _OpenIPMI.ipmi_user_t_set_num(self, num)

    def get_name(self):
        return _OpenIPMI.ipmi_user_t_get_name(self)

    def set_name(self, name):
        return _OpenIPMI.ipmi_user_t_set_name(self, name)

    def set_password(self, pw):
        return _OpenIPMI.ipmi_user_t_set_password(self, pw)

    def set_password2(self, pw):
        return _OpenIPMI.ipmi_user_t_set_password2(self, pw)

    def set_password_auto(self, pw):
        return _OpenIPMI.ipmi_user_t_set_password_auto(self, pw)

    def get_enable(self, enable):
        return _OpenIPMI.ipmi_user_t_get_enable(self, enable)

    def set_enable(self, val):
        return _OpenIPMI.ipmi_user_t_set_enable(self, val)

    def get_link_auth_enabled(self, enable):
        return _OpenIPMI.ipmi_user_t_get_link_auth_enabled(self, enable)

    def set_link_auth_enabled(self, val):
        return _OpenIPMI.ipmi_user_t_set_link_auth_enabled(self, val)

    def get_msg_auth_enabled(self, enable):
        return _OpenIPMI.ipmi_user_t_get_msg_auth_enabled(self, enable)

    def set_msg_auth_enabled(self, val):
        return _OpenIPMI.ipmi_user_t_set_msg_auth_enabled(self, val)

    def get_access_cb_only(self, cb):
        return _OpenIPMI.ipmi_user_t_get_access_cb_only(self, cb)

    def set_access_cb_only(self, val):
        return _OpenIPMI.ipmi_user_t_set_access_cb_only(self, val)

    def get_privilege_limit(self, limit):
        return _OpenIPMI.ipmi_user_t_get_privilege_limit(self, limit)

    def set_privilege_limit(self, val):
        return _OpenIPMI.ipmi_user_t_set_privilege_limit(self, val)

    def get_session_limit(self, limit):
        return _OpenIPMI.ipmi_user_t_get_session_limit(self, limit)

    def set_session_limit(self, val):
        return _OpenIPMI.ipmi_user_t_set_session_limit(self, val)

    def set_all(self):
        return _OpenIPMI.ipmi_user_t_set_all(self)

# Register ipmi_user_t in _OpenIPMI:
_OpenIPMI.ipmi_user_t_swigregister(ipmi_user_t)
class ipmi_lanparm_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_mc_id(self):
        return _OpenIPMI.ipmi_lanparm_t_get_mc_id(self)

    def get_channel(self):
        return _OpenIPMI.ipmi_lanparm_t_get_channel(self)

    def get_parm(self, parm, set, block, handler):
        return _OpenIPMI.ipmi_lanparm_t_get_parm(self, parm, set, block, handler)

    def set_parm(self, parm, value, handler=None):
        return _OpenIPMI.ipmi_lanparm_t_set_parm(self, parm, value, handler)

    def set_parm_array(self, parm, value, handler=None):
        return _OpenIPMI.ipmi_lanparm_t_set_parm_array(self, parm, value, handler)

    def get_config(self, handler):
        return _OpenIPMI.ipmi_lanparm_t_get_config(self, handler)

    def set_config(self, config, handler=None):
        return _OpenIPMI.ipmi_lanparm_t_set_config(self, config, handler)

    def clear_lock(self, config=None, handler=None):
        return _OpenIPMI.ipmi_lanparm_t_clear_lock(self, config, handler)

# Register ipmi_lanparm_t in _OpenIPMI:
_OpenIPMI.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_val(self, parm, index):
        return _OpenIPMI.ipmi_lan_config_t_get_val(self, parm, index)

    def set_val(self, parm, idx, type, value):
        return _OpenIPMI.ipmi_lan_config_t_set_val(self, parm, idx, type, value)

# Register ipmi_lan_config_t in _OpenIPMI:
_OpenIPMI.ipmi_lan_config_t_swigregister(ipmi_lan_config_t)
class ipmi_pef_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_mc_id(self):
        return _OpenIPMI.ipmi_pef_t_get_mc_id(self)

    def get_parm(self, parm, set, block, handler):
        return _OpenIPMI.ipmi_pef_t_get_parm(self, parm, set, block, handler)

    def set_parm(self, parm, value, handler=None):
        return _OpenIPMI.ipmi_pef_t_set_parm(self, parm, value, handler)

    def set_parm_array(self, parm, value, handler=None):
        return _OpenIPMI.ipmi_pef_t_set_parm_array(self, parm, value, handler)

    def get_config(self, handler):
        return _OpenIPMI.ipmi_pef_t_get_config(self, handler)

    def set_config(self, config, handler=None):
        return _OpenIPMI.ipmi_pef_t_set_config(self, config, handler)

    def clear_lock(self, config=None, handler=None):
        return _OpenIPMI.ipmi_pef_t_clear_lock(self, config, handler)

# Register ipmi_pef_t in _OpenIPMI:
_OpenIPMI.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_val(self, parm, index):
        return _OpenIPMI.ipmi_pef_config_t_get_val(self, parm, index)

    def set_val(self, parm, idx, type, value):
        return _OpenIPMI.ipmi_pef_config_t_set_val(self, parm, idx, type, value)

# Register ipmi_pef_config_t in _OpenIPMI:
_OpenIPMI.ipmi_pef_config_t_swigregister(ipmi_pef_config_t)
class ipmi_pet_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_mc_id(self):
        return _OpenIPMI.ipmi_pet_t_get_mc_id(self)

    def get_channel(self):
        return _OpenIPMI.ipmi_pet_t_get_channel(self)

    def get_ip_addr(self):
        return _OpenIPMI.ipmi_pet_t_get_ip_addr(self)

    def get_mac_addr(self):
        return _OpenIPMI.ipmi_pet_t_get_mac_addr(self)

    def get_eft_sel(self):
        return _OpenIPMI.ipmi_pet_t_get_eft_sel(self)

    def get_policy_num(self):
        return _OpenIPMI.ipmi_pet_t_get_policy_num(self)

    def get_apt_sel(self):
        return _OpenIPMI.ipmi_pet_t_get_apt_sel(self)

    def get_lan_dest_sel(self):
        return _OpenIPMI.ipmi_pet_t_get_lan_dest_sel(self)

# Register ipmi_pet_t in _OpenIPMI:
_OpenIPMI.ipmi_pet_t_swigregister(ipmi_pet_t)
class ipmi_cmdlang_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def handle(self, icmd):
        return _OpenIPMI.ipmi_cmdlang_t_handle(self, icmd)

    def is_help(self):
        return _OpenIPMI.ipmi_cmdlang_t_is_help(self)

    def get_err(self):
        return _OpenIPMI.ipmi_cmdlang_t_get_err(self)

    def get_errstr(self):
        return _OpenIPMI.ipmi_cmdlang_t_get_errstr(self)

    def get_objstr(self):
        return _OpenIPMI.ipmi_cmdlang_t_get_objstr(self)

    def get_location(self):
        return _OpenIPMI.ipmi_cmdlang_t_get_location(self)

# Register ipmi_cmdlang_t in _OpenIPMI:
_OpenIPMI.ipmi_cmdlang_t_swigregister(ipmi_cmdlang_t)
class ipmi_cmdlang_event_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def restart(self):
        return _OpenIPMI.ipmi_cmdlang_event_t_restart(self)

    def next_field(self, level, type, name, value):
        return _OpenIPMI.ipmi_cmdlang_event_t_next_field(self, level, type, name, value)

# Register ipmi_cmdlang_event_t in _OpenIPMI:
_OpenIPMI.ipmi_cmdlang_event_t_swigregister(ipmi_cmdlang_event_t)
class ipmi_sol_conn_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def set_ACK_timeout(self, timeout_usec):
        return _OpenIPMI.ipmi_sol_conn_t_set_ACK_timeout(self, timeout_usec)

    def get_ACK_timeout(self):
        return _OpenIPMI.ipmi_sol_conn_t_get_ACK_timeout(self)

    def set_ACK_retries(self, retries):
        return _OpenIPMI.ipmi_sol_conn_t_set_ACK_retries(self, retries)

    def get_ACK_retries(self):
        return _OpenIPMI.ipmi_sol_conn_t_get_ACK_retries(self)

    def set_use_authentication(self, use_authentication):
        return _OpenIPMI.ipmi_sol_conn_t_set_use_authentication(self, use_authentication)

    def get_use_authentication(self):
        return _OpenIPMI.ipmi_sol_conn_t_get_use_authentication(self)

    def set_use_encryption(self, use_encryption):
        return _OpenIPMI.ipmi_sol_conn_t_set_use_encryption(self, use_encryption)

    def get_use_encryption(self):
        return _OpenIPMI.ipmi_sol_conn_t_get_use_encryption(self)

    def set_shared_serial_alert_behavior(self, behavior):
        return _OpenIPMI.ipmi_sol_conn_t_set_shared_serial_alert_behavior(self, behavior)

    def get_shared_serial_alert_behavior(self):
        return _OpenIPMI.ipmi_sol_conn_t_get_shared_serial_alert_behavior(self)

    def set_deassert_CTS_DCD_DSR_on_connect(self, _assert):
        return _OpenIPMI.ipmi_sol_conn_t_set_deassert_CTS_DCD_DSR_on_connect(self, _assert)

    def get_deassert_CTS_DCD_DSR_on_connect(self):
        return _OpenIPMI.ipmi_sol_conn_t_get_deassert_CTS_DCD_DSR_on_connect(self)

    def set_bit_rate(self, rate):
        return _OpenIPMI.ipmi_sol_conn_t_set_bit_rate(self, rate)

    def get_bit_rate(self):
        return _OpenIPMI.ipmi_sol_conn_t_get_bit_rate(self)

    def open(self):
        return _OpenIPMI.ipmi_sol_conn_t_open(self)

    def close(self):
        return _OpenIPMI.ipmi_sol_conn_t_close(self)

    def force_close(self):
        return _OpenIPMI.ipmi_sol_conn_t_force_close(self)

    def write(self, buf, handler=None):
        return _OpenIPMI.ipmi_sol_conn_t_write(self, buf, handler)

    def release_nack(self):
        return _OpenIPMI.ipmi_sol_conn_t_release_nack(self)

    def send_break(self, handler=None):
        return _OpenIPMI.ipmi_sol_conn_t_send_break(self, handler)

    def set_CTS_assertable(self, asserted, handler=None):
        return _OpenIPMI.ipmi_sol_conn_t_set_CTS_assertable(self, asserted, handler)

    def set_DCD_DSR_asserted(self, asserted, handler=None):
        return _OpenIPMI.ipmi_sol_conn_t_set_DCD_DSR_asserted(self, asserted, handler)

    def set_RI_asserted(self, asserted, handler=None):
        return _OpenIPMI.ipmi_sol_conn_t_set_RI_asserted(self, asserted, handler)

    def flush(self, queue_selectors, handler=None):
        return _OpenIPMI.ipmi_sol_conn_t_flush(self, queue_selectors, handler)

# Register ipmi_sol_conn_t in _OpenIPMI:
_OpenIPMI.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_val(self, parm, index):
        return _OpenIPMI.ipmi_sol_config_t_get_val(self, parm, index)

    def set_val(self, parm, idx, type, value):
        return _OpenIPMI.ipmi_sol_config_t_set_val(self, parm, idx, type, value)

# Register ipmi_sol_config_t in _OpenIPMI:
_OpenIPMI.ipmi_sol_config_t_swigregister(ipmi_sol_config_t)
class ipmi_solparm_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def get_mc_id(self):
        return _OpenIPMI.ipmi_solparm_t_get_mc_id(self)

    def get_channel(self):
        return _OpenIPMI.ipmi_solparm_t_get_channel(self)

    def get_parm(self, parm, set, block, handler):
        return _OpenIPMI.ipmi_solparm_t_get_parm(self, parm, set, block, handler)

    def set_parm(self, parm, value, handler=None):
        return _OpenIPMI.ipmi_solparm_t_set_parm(self, parm, value, handler)

    def set_parm_array(self, parm, value, handler=None):
        return _OpenIPMI.ipmi_solparm_t_set_parm_array(self, parm, value, handler)

    def get_config(self, handler):
        return _OpenIPMI.ipmi_solparm_t_get_config(self, handler)

    def set_config(self, config, handler=None):
        return _OpenIPMI.ipmi_solparm_t_set_config(self, config, handler)

    def clear_lock(self, config=None, handler=None):
        return _OpenIPMI.ipmi_solparm_t_clear_lock(self, config, handler)

# Register ipmi_solparm_t in _OpenIPMI:
_OpenIPMI.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():
    return _OpenIPMI.enable_debug_malloc()

def enable_debug_msg():
    return _OpenIPMI.enable_debug_msg()

def disable_debug_msg():
    return _OpenIPMI.disable_debug_msg()

def enable_debug_rawmsg():
    return _OpenIPMI.enable_debug_rawmsg()

def disable_debug_rawmsg():
    return _OpenIPMI.disable_debug_rawmsg()

def init_glib():
    return _OpenIPMI.init_glib()

def init_glib12():
    return _OpenIPMI.init_glib12()

def init_tcl():
    return _OpenIPMI.init_tcl()

def init_posix():
    return _OpenIPMI.init_posix()

def init():
    return _OpenIPMI.init()

def shutdown_everything():
    return _OpenIPMI.shutdown_everything()

def wait_io(timeout):
    return _OpenIPMI.wait_io(timeout)
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, args, done=None, up=None):
    return _OpenIPMI.open_domain(name, args, done, up)

def open_domain2(name, args, done=None, up=None):
    return _OpenIPMI.open_domain2(name, args, done, up)

def open_domain3(name, options, args, done=None, up=None):
    return _OpenIPMI.open_domain3(name, options, args, done, up)

def parse_args_iter_help(help_cb):
    return _OpenIPMI.parse_args_iter_help(help_cb)

def parse_option_help():
    return _OpenIPMI.parse_option_help()

def add_domain_change_handler(handler):
    return _OpenIPMI.add_domain_change_handler(handler)

def remove_domain_change_handler(handler):
    return _OpenIPMI.remove_domain_change_handler(handler)

def set_log_handler(handler=None):
    return _OpenIPMI.set_log_handler(handler)

def color_string(color):
    return _OpenIPMI.color_string(color)

def lanparm_parm_to_str(parm):
    return _OpenIPMI.lanparm_parm_to_str(parm)

def lanparm_str_to_parm(str):
    return _OpenIPMI.lanparm_str_to_parm(str)

def lanconfig_enum_val(parm, val, nval, sval):
    return _OpenIPMI.lanconfig_enum_val(parm, val, nval, sval)

def lanconfig_enum_idx(parm, idx, sval):
    return _OpenIPMI.lanconfig_enum_idx(parm, idx, sval)

def pef_parm_to_str(parm):
    return _OpenIPMI.pef_parm_to_str(parm)

def pef_str_to_parm(str):
    return _OpenIPMI.pef_str_to_parm(str)

def pefconfig_enum_val(parm, val, nval, sval):
    return _OpenIPMI.pefconfig_enum_val(parm, val, nval, sval)

def pefconfig_enum_idx(parm, idx, sval):
    return _OpenIPMI.pefconfig_enum_idx(parm, idx, sval)

def solparm_parm_to_str(parm):
    return _OpenIPMI.solparm_parm_to_str(parm)

def solparm_str_to_parm(str):
    return _OpenIPMI.solparm_str_to_parm(str)

def solconfig_enum_val(parm, val, nval, sval):
    return _OpenIPMI.solconfig_enum_val(parm, val, nval, sval)

def solconfig_enum_idx(parm, idx, sval):
    return _OpenIPMI.solconfig_enum_idx(parm, idx, sval)

def get_threshold_access_support_string(val):
    return _OpenIPMI.get_threshold_access_support_string(val)

def get_hysteresis_support_string(val):
    return _OpenIPMI.get_hysteresis_support_string(val)

def get_event_support_string(val):
    return _OpenIPMI.get_event_support_string(val)

def channel_medium_string(val):
    return _OpenIPMI.channel_medium_string(val)

def channel_protocol_string(val):
    return _OpenIPMI.channel_protocol_string(val)

def channel_session_support_string(val):
    return _OpenIPMI.channel_session_support_string(val)

def channel_access_mode_string(val):
    return _OpenIPMI.channel_access_mode_string(val)

def privilege_string(val):
    return _OpenIPMI.privilege_string(val)

def authtype_string(val):
    return _OpenIPMI.authtype_string(val)

def get_error_string(val):
    return _OpenIPMI.get_error_string(val)
TIMEOUT_FOREVER = _OpenIPMI.TIMEOUT_FOREVER

def alloc_empty_args(con_type):
    return _OpenIPMI.alloc_empty_args(con_type)

def alloc_parse_args(args):
    return _OpenIPMI.alloc_parse_args(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):
    return _OpenIPMI.fru_index_to_str(idx)

def fru_str_to_index(name):
    return _OpenIPMI.fru_str_to_index(name)

def alloc_cmdlang(handler):
    return _OpenIPMI.alloc_cmdlang(handler)

def cmdlang_set_evinfo(evinfo):
    return _OpenIPMI.cmdlang_set_evinfo(evinfo)

def cmdlang_get_evinfo():
    return _OpenIPMI.cmdlang_get_evinfo()

def set_cmdlang_global_err_handler(handler):
    return _OpenIPMI.set_cmdlang_global_err_handler(handler)

def set_cmdlang_event_handler(handler):
    return _OpenIPMI.set_cmdlang_event_handler(handler)

def sol_state_string(val):
    return _OpenIPMI.sol_state_string(val)

