# 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.

"""Python interface to libftdi1"""

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _ftdi1
else:
    import _ftdi1

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



def usb_find_all(ftdi, vendor, product):
    r"""usb_find_all(context, vendor, product) -> (return_code, devlist)"""
    return _ftdi1.usb_find_all(ftdi, vendor, product)

def usb_get_strings(*args):
    r"""usb_get_strings(context, device) -> (return_code, manufacturer, description, serial)"""
    return _ftdi1.usb_get_strings(*args)

def usb_get_strings2(*args):
    r"""usb_get_strings(context, device) -> (return_code, manufacturer, description, serial)"""
    return _ftdi1.usb_get_strings2(*args)

def eeprom_get_strings(*args):
    r"""usb_get_strings(context, device) -> (return_code, manufacturer, description, serial)"""
    return _ftdi1.eeprom_get_strings(*args)

def read_data(ftdi, buf):
    r"""read_data(context) -> (return_code, buf)"""
    return _ftdi1.read_data(ftdi, buf)

def write_data(ftdi, buf):
    r"""write_data(context, data) -> return_code"""
    return _ftdi1.write_data(ftdi, buf)

def read_data_get_chunksize(ftdi):
    r"""read_data_get_chunksize(context ftdi) -> int"""
    return _ftdi1.read_data_get_chunksize(ftdi)

def write_data_get_chunksize(ftdi):
    r"""write_data_get_chunksize(context ftdi) -> int"""
    return _ftdi1.write_data_get_chunksize(ftdi)

def read_pins(ftdi):
    r"""read_pins(context) -> (return_code, pins)"""
    return _ftdi1.read_pins(ftdi)

def get_latency_timer(ftdi):
    r"""get_latency_timer(context ftdi) -> int"""
    return _ftdi1.get_latency_timer(ftdi)

def poll_modem_status(ftdi):
    r"""poll_modem_status(context ftdi) -> int"""
    return _ftdi1.poll_modem_status(ftdi)

def get_eeprom_value(ftdi, value_name):
    r"""get_eeprom_value(context ftdi, enum ftdi_eeprom_value value_name) -> int"""
    return _ftdi1.get_eeprom_value(ftdi, value_name)

def get_eeprom_buf(ftdi, buf):
    r"""get_eeprom_buf(context ftdi, unsigned char * buf) -> int"""
    return _ftdi1.get_eeprom_buf(ftdi, buf)

def read_eeprom_location(ftdi, eeprom_addr):
    r"""read_eeprom_location(context, eeprom_addr) -> (return_code, eeprom_val)"""
    return _ftdi1.read_eeprom_location(ftdi, eeprom_addr)

def read_chipid(ftdi):
    r"""ftdi_read_chipid(context) -> (return_code, chipid)"""
    return _ftdi1.read_chipid(ftdi)
TYPE_AM = _ftdi1.TYPE_AM

TYPE_BM = _ftdi1.TYPE_BM

TYPE_2232C = _ftdi1.TYPE_2232C

TYPE_R = _ftdi1.TYPE_R

TYPE_2232H = _ftdi1.TYPE_2232H

TYPE_4232H = _ftdi1.TYPE_4232H

TYPE_232H = _ftdi1.TYPE_232H

TYPE_230X = _ftdi1.TYPE_230X

NONE = _ftdi1.NONE

ODD = _ftdi1.ODD

EVEN = _ftdi1.EVEN

MARK = _ftdi1.MARK

SPACE = _ftdi1.SPACE

STOP_BIT_1 = _ftdi1.STOP_BIT_1

STOP_BIT_15 = _ftdi1.STOP_BIT_15

STOP_BIT_2 = _ftdi1.STOP_BIT_2

BITS_7 = _ftdi1.BITS_7

BITS_8 = _ftdi1.BITS_8

BREAK_OFF = _ftdi1.BREAK_OFF

BREAK_ON = _ftdi1.BREAK_ON

BITMODE_RESET = _ftdi1.BITMODE_RESET

BITMODE_BITBANG = _ftdi1.BITMODE_BITBANG

BITMODE_MPSSE = _ftdi1.BITMODE_MPSSE

BITMODE_SYNCBB = _ftdi1.BITMODE_SYNCBB

BITMODE_MCU = _ftdi1.BITMODE_MCU

BITMODE_OPTO = _ftdi1.BITMODE_OPTO

BITMODE_CBUS = _ftdi1.BITMODE_CBUS

BITMODE_SYNCFF = _ftdi1.BITMODE_SYNCFF

BITMODE_FT1284 = _ftdi1.BITMODE_FT1284

INTERFACE_ANY = _ftdi1.INTERFACE_ANY

INTERFACE_A = _ftdi1.INTERFACE_A

INTERFACE_B = _ftdi1.INTERFACE_B

INTERFACE_C = _ftdi1.INTERFACE_C

INTERFACE_D = _ftdi1.INTERFACE_D

AUTO_DETACH_SIO_MODULE = _ftdi1.AUTO_DETACH_SIO_MODULE

DONT_DETACH_SIO_MODULE = _ftdi1.DONT_DETACH_SIO_MODULE

AUTO_DETACH_REATACH_SIO_MODULE = _ftdi1.AUTO_DETACH_REATACH_SIO_MODULE

MPSSE_WRITE_NEG = _ftdi1.MPSSE_WRITE_NEG

MPSSE_BITMODE = _ftdi1.MPSSE_BITMODE

MPSSE_READ_NEG = _ftdi1.MPSSE_READ_NEG

MPSSE_LSB = _ftdi1.MPSSE_LSB

MPSSE_DO_WRITE = _ftdi1.MPSSE_DO_WRITE

MPSSE_DO_READ = _ftdi1.MPSSE_DO_READ

MPSSE_WRITE_TMS = _ftdi1.MPSSE_WRITE_TMS

SET_BITS_LOW = _ftdi1.SET_BITS_LOW

SET_BITS_HIGH = _ftdi1.SET_BITS_HIGH

GET_BITS_LOW = _ftdi1.GET_BITS_LOW

GET_BITS_HIGH = _ftdi1.GET_BITS_HIGH

LOOPBACK_START = _ftdi1.LOOPBACK_START

LOOPBACK_END = _ftdi1.LOOPBACK_END

TCK_DIVISOR = _ftdi1.TCK_DIVISOR

DIS_DIV_5 = _ftdi1.DIS_DIV_5

EN_DIV_5 = _ftdi1.EN_DIV_5

EN_3_PHASE = _ftdi1.EN_3_PHASE

DIS_3_PHASE = _ftdi1.DIS_3_PHASE

CLK_BITS = _ftdi1.CLK_BITS

CLK_BYTES = _ftdi1.CLK_BYTES

CLK_WAIT_HIGH = _ftdi1.CLK_WAIT_HIGH

CLK_WAIT_LOW = _ftdi1.CLK_WAIT_LOW

EN_ADAPTIVE = _ftdi1.EN_ADAPTIVE

DIS_ADAPTIVE = _ftdi1.DIS_ADAPTIVE

CLK_BYTES_OR_HIGH = _ftdi1.CLK_BYTES_OR_HIGH

CLK_BYTES_OR_LOW = _ftdi1.CLK_BYTES_OR_LOW

DRIVE_OPEN_COLLECTOR = _ftdi1.DRIVE_OPEN_COLLECTOR

SEND_IMMEDIATE = _ftdi1.SEND_IMMEDIATE

WAIT_ON_HIGH = _ftdi1.WAIT_ON_HIGH

WAIT_ON_LOW = _ftdi1.WAIT_ON_LOW

READ_SHORT = _ftdi1.READ_SHORT

READ_EXTENDED = _ftdi1.READ_EXTENDED

WRITE_SHORT = _ftdi1.WRITE_SHORT

WRITE_EXTENDED = _ftdi1.WRITE_EXTENDED

SIO_RESET = _ftdi1.SIO_RESET

SIO_MODEM_CTRL = _ftdi1.SIO_MODEM_CTRL

SIO_SET_FLOW_CTRL = _ftdi1.SIO_SET_FLOW_CTRL

SIO_SET_BAUD_RATE = _ftdi1.SIO_SET_BAUD_RATE

SIO_SET_DATA = _ftdi1.SIO_SET_DATA

SIO_RESET_REQUEST = _ftdi1.SIO_RESET_REQUEST

SIO_SET_BAUDRATE_REQUEST = _ftdi1.SIO_SET_BAUDRATE_REQUEST

SIO_SET_DATA_REQUEST = _ftdi1.SIO_SET_DATA_REQUEST

SIO_SET_FLOW_CTRL_REQUEST = _ftdi1.SIO_SET_FLOW_CTRL_REQUEST

SIO_SET_MODEM_CTRL_REQUEST = _ftdi1.SIO_SET_MODEM_CTRL_REQUEST

SIO_POLL_MODEM_STATUS_REQUEST = _ftdi1.SIO_POLL_MODEM_STATUS_REQUEST

SIO_SET_EVENT_CHAR_REQUEST = _ftdi1.SIO_SET_EVENT_CHAR_REQUEST

SIO_SET_ERROR_CHAR_REQUEST = _ftdi1.SIO_SET_ERROR_CHAR_REQUEST

SIO_SET_LATENCY_TIMER_REQUEST = _ftdi1.SIO_SET_LATENCY_TIMER_REQUEST

SIO_GET_LATENCY_TIMER_REQUEST = _ftdi1.SIO_GET_LATENCY_TIMER_REQUEST

SIO_SET_BITMODE_REQUEST = _ftdi1.SIO_SET_BITMODE_REQUEST

SIO_READ_PINS_REQUEST = _ftdi1.SIO_READ_PINS_REQUEST

SIO_READ_EEPROM_REQUEST = _ftdi1.SIO_READ_EEPROM_REQUEST

SIO_WRITE_EEPROM_REQUEST = _ftdi1.SIO_WRITE_EEPROM_REQUEST

SIO_ERASE_EEPROM_REQUEST = _ftdi1.SIO_ERASE_EEPROM_REQUEST

SIO_RESET_SIO = _ftdi1.SIO_RESET_SIO

SIO_RESET_PURGE_RX = _ftdi1.SIO_RESET_PURGE_RX

SIO_RESET_PURGE_TX = _ftdi1.SIO_RESET_PURGE_TX

SIO_TCIFLUSH = _ftdi1.SIO_TCIFLUSH

SIO_TCOFLUSH = _ftdi1.SIO_TCOFLUSH

SIO_DISABLE_FLOW_CTRL = _ftdi1.SIO_DISABLE_FLOW_CTRL

SIO_RTS_CTS_HS = _ftdi1.SIO_RTS_CTS_HS

SIO_DTR_DSR_HS = _ftdi1.SIO_DTR_DSR_HS

SIO_XON_XOFF_HS = _ftdi1.SIO_XON_XOFF_HS

SIO_SET_DTR_MASK = _ftdi1.SIO_SET_DTR_MASK

SIO_SET_DTR_HIGH = _ftdi1.SIO_SET_DTR_HIGH

SIO_SET_DTR_LOW = _ftdi1.SIO_SET_DTR_LOW

SIO_SET_RTS_MASK = _ftdi1.SIO_SET_RTS_MASK

SIO_SET_RTS_HIGH = _ftdi1.SIO_SET_RTS_HIGH

SIO_SET_RTS_LOW = _ftdi1.SIO_SET_RTS_LOW

class transfer_control(object):
    r"""Proxy of C ftdi_transfer_control struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    completed = property(_ftdi1.transfer_control_completed_get, _ftdi1.transfer_control_completed_set, doc=r"""completed : int""")
    buf = property(_ftdi1.transfer_control_buf_get, _ftdi1.transfer_control_buf_set, doc=r"""buf : p.unsigned char""")
    size = property(_ftdi1.transfer_control_size_get, _ftdi1.transfer_control_size_set, doc=r"""size : int""")
    offset = property(_ftdi1.transfer_control_offset_get, _ftdi1.transfer_control_offset_set, doc=r"""offset : int""")
    ftdi = property(_ftdi1.transfer_control_ftdi_get, _ftdi1.transfer_control_ftdi_set, doc=r"""ftdi : p.struct ftdi_context""")
    transfer = property(_ftdi1.transfer_control_transfer_get, _ftdi1.transfer_control_transfer_set, doc=r"""transfer : p.struct libusb_transfer""")

    def __init__(self):
        r"""__init__(transfer_control self) -> transfer_control"""
        _ftdi1.transfer_control_swiginit(self, _ftdi1.new_transfer_control())
    __swig_destroy__ = _ftdi1.delete_transfer_control

# Register transfer_control in _ftdi1:
_ftdi1.transfer_control_swigregister(transfer_control)
class context(object):
    r"""Proxy of C ftdi_context struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    usb_ctx = property(_ftdi1.context_usb_ctx_get, _ftdi1.context_usb_ctx_set, doc=r"""usb_ctx : p.struct libusb_context""")
    usb_dev = property(_ftdi1.context_usb_dev_get, _ftdi1.context_usb_dev_set, doc=r"""usb_dev : p.struct libusb_device_handle""")
    usb_read_timeout = property(_ftdi1.context_usb_read_timeout_get, _ftdi1.context_usb_read_timeout_set, doc=r"""usb_read_timeout : int""")
    usb_write_timeout = property(_ftdi1.context_usb_write_timeout_get, _ftdi1.context_usb_write_timeout_set, doc=r"""usb_write_timeout : int""")
    type = property(_ftdi1.context_type_get, _ftdi1.context_type_set, doc=r"""type : enum ftdi_chip_type""")
    baudrate = property(_ftdi1.context_baudrate_get, _ftdi1.context_baudrate_set, doc=r"""baudrate : int""")
    bitbang_enabled = property(_ftdi1.context_bitbang_enabled_get, _ftdi1.context_bitbang_enabled_set, doc=r"""bitbang_enabled : unsigned char""")
    readbuffer = property(_ftdi1.context_readbuffer_get, _ftdi1.context_readbuffer_set, doc=r"""readbuffer : p.unsigned char""")
    readbuffer_offset = property(_ftdi1.context_readbuffer_offset_get, _ftdi1.context_readbuffer_offset_set, doc=r"""readbuffer_offset : unsigned int""")
    readbuffer_remaining = property(_ftdi1.context_readbuffer_remaining_get, _ftdi1.context_readbuffer_remaining_set, doc=r"""readbuffer_remaining : unsigned int""")
    readbuffer_chunksize = property(_ftdi1.context_readbuffer_chunksize_get, _ftdi1.context_readbuffer_chunksize_set, doc=r"""readbuffer_chunksize : unsigned int""")
    writebuffer_chunksize = property(_ftdi1.context_writebuffer_chunksize_get, _ftdi1.context_writebuffer_chunksize_set, doc=r"""writebuffer_chunksize : unsigned int""")
    max_packet_size = property(_ftdi1.context_max_packet_size_get, _ftdi1.context_max_packet_size_set, doc=r"""max_packet_size : unsigned int""")
    interface = property(_ftdi1.context_interface_get, _ftdi1.context_interface_set, doc=r"""interface : int""")
    index = property(_ftdi1.context_index_get, _ftdi1.context_index_set, doc=r"""index : int""")
    in_ep = property(_ftdi1.context_in_ep_get, _ftdi1.context_in_ep_set, doc=r"""in_ep : int""")
    out_ep = property(_ftdi1.context_out_ep_get, _ftdi1.context_out_ep_set, doc=r"""out_ep : int""")
    bitbang_mode = property(_ftdi1.context_bitbang_mode_get, _ftdi1.context_bitbang_mode_set, doc=r"""bitbang_mode : unsigned char""")
    eeprom = property(_ftdi1.context_eeprom_get, _ftdi1.context_eeprom_set, doc=r"""eeprom : p.struct ftdi_eeprom""")
    error_str = property(_ftdi1.context_error_str_get, _ftdi1.context_error_str_set, doc=r"""error_str : p.q(const).char""")
    module_detach_mode = property(_ftdi1.context_module_detach_mode_get, _ftdi1.context_module_detach_mode_set, doc=r"""module_detach_mode : enum ftdi_module_detach_mode""")

    def __init__(self):
        r"""__init__(context self) -> context"""
        _ftdi1.context_swiginit(self, _ftdi1.new_context())
    __swig_destroy__ = _ftdi1.delete_context

# Register context in _ftdi1:
_ftdi1.context_swigregister(context)
VENDOR_ID = _ftdi1.VENDOR_ID

PRODUCT_ID = _ftdi1.PRODUCT_ID

SELF_POWERED = _ftdi1.SELF_POWERED

REMOTE_WAKEUP = _ftdi1.REMOTE_WAKEUP

IS_NOT_PNP = _ftdi1.IS_NOT_PNP

SUSPEND_DBUS7 = _ftdi1.SUSPEND_DBUS7

IN_IS_ISOCHRONOUS = _ftdi1.IN_IS_ISOCHRONOUS

OUT_IS_ISOCHRONOUS = _ftdi1.OUT_IS_ISOCHRONOUS

SUSPEND_PULL_DOWNS = _ftdi1.SUSPEND_PULL_DOWNS

USE_SERIAL = _ftdi1.USE_SERIAL

USB_VERSION = _ftdi1.USB_VERSION

USE_USB_VERSION = _ftdi1.USE_USB_VERSION

MAX_POWER = _ftdi1.MAX_POWER

CHANNEL_A_TYPE = _ftdi1.CHANNEL_A_TYPE

CHANNEL_B_TYPE = _ftdi1.CHANNEL_B_TYPE

CHANNEL_A_DRIVER = _ftdi1.CHANNEL_A_DRIVER

CHANNEL_B_DRIVER = _ftdi1.CHANNEL_B_DRIVER

CBUS_FUNCTION_0 = _ftdi1.CBUS_FUNCTION_0

CBUS_FUNCTION_1 = _ftdi1.CBUS_FUNCTION_1

CBUS_FUNCTION_2 = _ftdi1.CBUS_FUNCTION_2

CBUS_FUNCTION_3 = _ftdi1.CBUS_FUNCTION_3

CBUS_FUNCTION_4 = _ftdi1.CBUS_FUNCTION_4

CBUS_FUNCTION_5 = _ftdi1.CBUS_FUNCTION_5

CBUS_FUNCTION_6 = _ftdi1.CBUS_FUNCTION_6

CBUS_FUNCTION_7 = _ftdi1.CBUS_FUNCTION_7

CBUS_FUNCTION_8 = _ftdi1.CBUS_FUNCTION_8

CBUS_FUNCTION_9 = _ftdi1.CBUS_FUNCTION_9

HIGH_CURRENT = _ftdi1.HIGH_CURRENT

HIGH_CURRENT_A = _ftdi1.HIGH_CURRENT_A

HIGH_CURRENT_B = _ftdi1.HIGH_CURRENT_B

INVERT = _ftdi1.INVERT

GROUP0_DRIVE = _ftdi1.GROUP0_DRIVE

GROUP0_SCHMITT = _ftdi1.GROUP0_SCHMITT

GROUP0_SLEW = _ftdi1.GROUP0_SLEW

GROUP1_DRIVE = _ftdi1.GROUP1_DRIVE

GROUP1_SCHMITT = _ftdi1.GROUP1_SCHMITT

GROUP1_SLEW = _ftdi1.GROUP1_SLEW

GROUP2_DRIVE = _ftdi1.GROUP2_DRIVE

GROUP2_SCHMITT = _ftdi1.GROUP2_SCHMITT

GROUP2_SLEW = _ftdi1.GROUP2_SLEW

GROUP3_DRIVE = _ftdi1.GROUP3_DRIVE

GROUP3_SCHMITT = _ftdi1.GROUP3_SCHMITT

GROUP3_SLEW = _ftdi1.GROUP3_SLEW

CHIP_SIZE = _ftdi1.CHIP_SIZE

CHIP_TYPE = _ftdi1.CHIP_TYPE

POWER_SAVE = _ftdi1.POWER_SAVE

CLOCK_POLARITY = _ftdi1.CLOCK_POLARITY

DATA_ORDER = _ftdi1.DATA_ORDER

FLOW_CONTROL = _ftdi1.FLOW_CONTROL

CHANNEL_C_DRIVER = _ftdi1.CHANNEL_C_DRIVER

CHANNEL_D_DRIVER = _ftdi1.CHANNEL_D_DRIVER

CHANNEL_A_RS485 = _ftdi1.CHANNEL_A_RS485

CHANNEL_B_RS485 = _ftdi1.CHANNEL_B_RS485

CHANNEL_C_RS485 = _ftdi1.CHANNEL_C_RS485

CHANNEL_D_RS485 = _ftdi1.CHANNEL_D_RS485

RELEASE_NUMBER = _ftdi1.RELEASE_NUMBER

EXTERNAL_OSCILLATOR = _ftdi1.EXTERNAL_OSCILLATOR

USER_DATA_ADDR = _ftdi1.USER_DATA_ADDR

class device_list(object):
    r"""Proxy of C ftdi_device_list struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    next = property(_ftdi1.device_list_next_get, _ftdi1.device_list_next_set, doc=r"""next : p.struct ftdi_device_list""")
    dev = property(_ftdi1.device_list_dev_get, _ftdi1.device_list_dev_set, doc=r"""dev : p.struct libusb_device""")

    def __init__(self):
        r"""__init__(device_list self) -> device_list"""
        _ftdi1.device_list_swiginit(self, _ftdi1.new_device_list())
    __swig_destroy__ = _ftdi1.delete_device_list

# Register device_list in _ftdi1:
_ftdi1.device_list_swigregister(device_list)
FT1284_CLK_IDLE_STATE = _ftdi1.FT1284_CLK_IDLE_STATE

FT1284_DATA_LSB = _ftdi1.FT1284_DATA_LSB

FT1284_FLOW_CONTROL = _ftdi1.FT1284_FLOW_CONTROL

POWER_SAVE_DISABLE_H = _ftdi1.POWER_SAVE_DISABLE_H

USE_SERIAL_NUM = _ftdi1.USE_SERIAL_NUM

CBUS_TXDEN = _ftdi1.CBUS_TXDEN

CBUS_PWREN = _ftdi1.CBUS_PWREN

CBUS_RXLED = _ftdi1.CBUS_RXLED

CBUS_TXLED = _ftdi1.CBUS_TXLED

CBUS_TXRXLED = _ftdi1.CBUS_TXRXLED

CBUS_SLEEP = _ftdi1.CBUS_SLEEP

CBUS_CLK48 = _ftdi1.CBUS_CLK48

CBUS_CLK24 = _ftdi1.CBUS_CLK24

CBUS_CLK12 = _ftdi1.CBUS_CLK12

CBUS_CLK6 = _ftdi1.CBUS_CLK6

CBUS_IOMODE = _ftdi1.CBUS_IOMODE

CBUS_BB_WR = _ftdi1.CBUS_BB_WR

CBUS_BB_RD = _ftdi1.CBUS_BB_RD

CBUSH_TRISTATE = _ftdi1.CBUSH_TRISTATE

CBUSH_TXLED = _ftdi1.CBUSH_TXLED

CBUSH_RXLED = _ftdi1.CBUSH_RXLED

CBUSH_TXRXLED = _ftdi1.CBUSH_TXRXLED

CBUSH_PWREN = _ftdi1.CBUSH_PWREN

CBUSH_SLEEP = _ftdi1.CBUSH_SLEEP

CBUSH_DRIVE_0 = _ftdi1.CBUSH_DRIVE_0

CBUSH_DRIVE1 = _ftdi1.CBUSH_DRIVE1

CBUSH_IOMODE = _ftdi1.CBUSH_IOMODE

CBUSH_TXDEN = _ftdi1.CBUSH_TXDEN

CBUSH_CLK30 = _ftdi1.CBUSH_CLK30

CBUSH_CLK15 = _ftdi1.CBUSH_CLK15

CBUSH_CLK7_5 = _ftdi1.CBUSH_CLK7_5

CBUSX_TRISTATE = _ftdi1.CBUSX_TRISTATE

CBUSX_TXLED = _ftdi1.CBUSX_TXLED

CBUSX_RXLED = _ftdi1.CBUSX_RXLED

CBUSX_TXRXLED = _ftdi1.CBUSX_TXRXLED

CBUSX_PWREN = _ftdi1.CBUSX_PWREN

CBUSX_SLEEP = _ftdi1.CBUSX_SLEEP

CBUSX_DRIVE_0 = _ftdi1.CBUSX_DRIVE_0

CBUSX_DRIVE1 = _ftdi1.CBUSX_DRIVE1

CBUSX_IOMODE = _ftdi1.CBUSX_IOMODE

CBUSX_TXDEN = _ftdi1.CBUSX_TXDEN

CBUSX_CLK24 = _ftdi1.CBUSX_CLK24

CBUSX_CLK12 = _ftdi1.CBUSX_CLK12

CBUSX_CLK6 = _ftdi1.CBUSX_CLK6

CBUSX_BAT_DETECT = _ftdi1.CBUSX_BAT_DETECT

CBUSX_BAT_DETECT_NEG = _ftdi1.CBUSX_BAT_DETECT_NEG

CBUSX_I2C_TXE = _ftdi1.CBUSX_I2C_TXE

CBUSX_I2C_RXF = _ftdi1.CBUSX_I2C_RXF

CBUSX_VBUS_SENSE = _ftdi1.CBUSX_VBUS_SENSE

CBUSX_BB_WR = _ftdi1.CBUSX_BB_WR

CBUSX_BB_RD = _ftdi1.CBUSX_BB_RD

CBUSX_TIME_STAMP = _ftdi1.CBUSX_TIME_STAMP

CBUSX_AWAKE = _ftdi1.CBUSX_AWAKE

INVERT_TXD = _ftdi1.INVERT_TXD

INVERT_RXD = _ftdi1.INVERT_RXD

INVERT_RTS = _ftdi1.INVERT_RTS

INVERT_CTS = _ftdi1.INVERT_CTS

INVERT_DTR = _ftdi1.INVERT_DTR

INVERT_DSR = _ftdi1.INVERT_DSR

INVERT_DCD = _ftdi1.INVERT_DCD

INVERT_RI = _ftdi1.INVERT_RI

CHANNEL_IS_UART = _ftdi1.CHANNEL_IS_UART

CHANNEL_IS_FIFO = _ftdi1.CHANNEL_IS_FIFO

CHANNEL_IS_OPTO = _ftdi1.CHANNEL_IS_OPTO

CHANNEL_IS_CPU = _ftdi1.CHANNEL_IS_CPU

CHANNEL_IS_FT1284 = _ftdi1.CHANNEL_IS_FT1284

CHANNEL_IS_RS485 = _ftdi1.CHANNEL_IS_RS485

DRIVE_4MA = _ftdi1.DRIVE_4MA

DRIVE_8MA = _ftdi1.DRIVE_8MA

DRIVE_12MA = _ftdi1.DRIVE_12MA

DRIVE_16MA = _ftdi1.DRIVE_16MA

SLOW_SLEW = _ftdi1.SLOW_SLEW

IS_SCHMITT = _ftdi1.IS_SCHMITT

DRIVER_VCP = _ftdi1.DRIVER_VCP

DRIVER_VCPH = _ftdi1.DRIVER_VCPH

USE_USB_VERSION_BIT = _ftdi1.USE_USB_VERSION_BIT

SUSPEND_DBUS7_BIT = _ftdi1.SUSPEND_DBUS7_BIT

HIGH_CURRENT_DRIVE = _ftdi1.HIGH_CURRENT_DRIVE

HIGH_CURRENT_DRIVE_R = _ftdi1.HIGH_CURRENT_DRIVE_R

class size_and_time(object):
    r"""Proxy of C size_and_time struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    totalBytes = property(_ftdi1.size_and_time_totalBytes_get, _ftdi1.size_and_time_totalBytes_set, doc=r"""totalBytes : uint64_t""")
    time = property(_ftdi1.size_and_time_time_get, _ftdi1.size_and_time_time_set, doc=r"""time : struct timeval""")

    def __init__(self):
        r"""__init__(size_and_time self) -> size_and_time"""
        _ftdi1.size_and_time_swiginit(self, _ftdi1.new_size_and_time())
    __swig_destroy__ = _ftdi1.delete_size_and_time

# Register size_and_time in _ftdi1:
_ftdi1.size_and_time_swigregister(size_and_time)
class FTDIProgressInfo(object):
    r"""Proxy of C FTDIProgressInfo struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    first = property(_ftdi1.FTDIProgressInfo_first_get, _ftdi1.FTDIProgressInfo_first_set, doc=r"""first : struct size_and_time""")
    prev = property(_ftdi1.FTDIProgressInfo_prev_get, _ftdi1.FTDIProgressInfo_prev_set, doc=r"""prev : struct size_and_time""")
    current = property(_ftdi1.FTDIProgressInfo_current_get, _ftdi1.FTDIProgressInfo_current_set, doc=r"""current : struct size_and_time""")
    totalTime = property(_ftdi1.FTDIProgressInfo_totalTime_get, _ftdi1.FTDIProgressInfo_totalTime_set, doc=r"""totalTime : double""")
    totalRate = property(_ftdi1.FTDIProgressInfo_totalRate_get, _ftdi1.FTDIProgressInfo_totalRate_set, doc=r"""totalRate : double""")
    currentRate = property(_ftdi1.FTDIProgressInfo_currentRate_get, _ftdi1.FTDIProgressInfo_currentRate_set, doc=r"""currentRate : double""")

    def __init__(self):
        r"""__init__(FTDIProgressInfo self) -> FTDIProgressInfo"""
        _ftdi1.FTDIProgressInfo_swiginit(self, _ftdi1.new_FTDIProgressInfo())
    __swig_destroy__ = _ftdi1.delete_FTDIProgressInfo

# Register FTDIProgressInfo in _ftdi1:
_ftdi1.FTDIProgressInfo_swigregister(FTDIProgressInfo)
class version_info(object):
    r"""Proxy of C ftdi_version_info struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    major = property(_ftdi1.version_info_major_get, _ftdi1.version_info_major_set, doc=r"""major : int""")
    minor = property(_ftdi1.version_info_minor_get, _ftdi1.version_info_minor_set, doc=r"""minor : int""")
    micro = property(_ftdi1.version_info_micro_get, _ftdi1.version_info_micro_set, doc=r"""micro : int""")
    version_str = property(_ftdi1.version_info_version_str_get, doc=r"""version_str : p.q(const).char""")
    snapshot_str = property(_ftdi1.version_info_snapshot_str_get, doc=r"""snapshot_str : p.q(const).char""")

    def __init__(self):
        r"""__init__(version_info self) -> version_info"""
        _ftdi1.version_info_swiginit(self, _ftdi1.new_version_info())
    __swig_destroy__ = _ftdi1.delete_version_info

# Register version_info in _ftdi1:
_ftdi1.version_info_swigregister(version_info)

def init(ftdi):
    r"""init(context ftdi) -> int"""
    return _ftdi1.init(ftdi)

def new():
    r"""new() -> context"""
    return _ftdi1.new()

def set_interface(ftdi, interface):
    r"""set_interface(context ftdi, enum ftdi_interface interface) -> int"""
    return _ftdi1.set_interface(ftdi, interface)

def deinit(ftdi):
    r"""deinit(context ftdi)"""
    return _ftdi1.deinit(ftdi)

def free(ftdi):
    r"""free(context ftdi)"""
    return _ftdi1.free(ftdi)

def set_usbdev(ftdi, usbdev):
    r"""set_usbdev(context ftdi, struct libusb_device_handle * usbdev)"""
    return _ftdi1.set_usbdev(ftdi, usbdev)

def get_library_version():
    r"""get_library_version() -> version_info"""
    return _ftdi1.get_library_version()

def list_free(devlist):
    r"""list_free(struct ftdi_device_list ** devlist)"""
    return _ftdi1.list_free(devlist)

def list_free2(devlist):
    r"""list_free2(device_list devlist)"""
    return _ftdi1.list_free2(devlist)

def eeprom_set_strings(ftdi, manufacturer, product, serial):
    r"""eeprom_set_strings(context ftdi, char const * manufacturer, char const * product, char const * serial) -> int"""
    return _ftdi1.eeprom_set_strings(ftdi, manufacturer, product, serial)

def usb_open(ftdi, vendor, product):
    r"""usb_open(context ftdi, int vendor, int product) -> int"""
    return _ftdi1.usb_open(ftdi, vendor, product)

def usb_open_desc(ftdi, vendor, product, description, serial):
    r"""usb_open_desc(context ftdi, int vendor, int product, char const * description, char const * serial) -> int"""
    return _ftdi1.usb_open_desc(ftdi, vendor, product, description, serial)

def usb_open_desc_index(ftdi, vendor, product, description, serial, index):
    r"""usb_open_desc_index(context ftdi, int vendor, int product, char const * description, char const * serial, unsigned int index) -> int"""
    return _ftdi1.usb_open_desc_index(ftdi, vendor, product, description, serial, index)

def usb_open_bus_addr(ftdi, bus, addr):
    r"""usb_open_bus_addr(context ftdi, uint8_t bus, uint8_t addr) -> int"""
    return _ftdi1.usb_open_bus_addr(ftdi, bus, addr)

def usb_open_dev(ftdi, dev):
    r"""usb_open_dev(context ftdi, struct libusb_device * dev) -> int"""
    return _ftdi1.usb_open_dev(ftdi, dev)

def usb_open_string(ftdi, description):
    r"""usb_open_string(context ftdi, char const * description) -> int"""
    return _ftdi1.usb_open_string(ftdi, description)

def usb_close(ftdi):
    r"""usb_close(context ftdi) -> int"""
    return _ftdi1.usb_close(ftdi)

def usb_reset(ftdi):
    r"""usb_reset(context ftdi) -> int"""
    return _ftdi1.usb_reset(ftdi)

def tciflush(ftdi):
    r"""tciflush(context ftdi) -> int"""
    return _ftdi1.tciflush(ftdi)

def tcoflush(ftdi):
    r"""tcoflush(context ftdi) -> int"""
    return _ftdi1.tcoflush(ftdi)

def tcioflush(ftdi):
    r"""tcioflush(context ftdi) -> int"""
    return _ftdi1.tcioflush(ftdi)

def usb_purge_rx_buffer(ftdi):
    r"""usb_purge_rx_buffer(context ftdi) -> int"""
    return _ftdi1.usb_purge_rx_buffer(ftdi)

def usb_purge_tx_buffer(ftdi):
    r"""usb_purge_tx_buffer(context ftdi) -> int"""
    return _ftdi1.usb_purge_tx_buffer(ftdi)

def usb_purge_buffers(ftdi):
    r"""usb_purge_buffers(context ftdi) -> int"""
    return _ftdi1.usb_purge_buffers(ftdi)

def set_baudrate(ftdi, baudrate):
    r"""set_baudrate(context ftdi, int baudrate) -> int"""
    return _ftdi1.set_baudrate(ftdi, baudrate)

def set_line_property(ftdi, bits, sbit, parity):
    r"""set_line_property(context ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity) -> int"""
    return _ftdi1.set_line_property(ftdi, bits, sbit, parity)

def set_line_property2(ftdi, bits, sbit, parity, break_type):
    r"""set_line_property2(context ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, enum ftdi_break_type break_type) -> int"""
    return _ftdi1.set_line_property2(ftdi, bits, sbit, parity, break_type)

def read_data_set_chunksize(ftdi, chunksize):
    r"""read_data_set_chunksize(context ftdi, unsigned int chunksize) -> int"""
    return _ftdi1.read_data_set_chunksize(ftdi, chunksize)

def write_data_set_chunksize(ftdi, chunksize):
    r"""write_data_set_chunksize(context ftdi, unsigned int chunksize) -> int"""
    return _ftdi1.write_data_set_chunksize(ftdi, chunksize)

def readstream(ftdi, callback, userdata, packetsPerTransfer, numTransfers):
    r"""readstream(context ftdi, FTDIStreamCallback * callback, void * userdata, int packetsPerTransfer, int numTransfers) -> int"""
    return _ftdi1.readstream(ftdi, callback, userdata, packetsPerTransfer, numTransfers)

def write_data_submit(ftdi, buf, size):
    r"""write_data_submit(context ftdi, unsigned char * buf, int size) -> transfer_control"""
    return _ftdi1.write_data_submit(ftdi, buf, size)

def read_data_submit(ftdi, buf, size):
    r"""read_data_submit(context ftdi, unsigned char * buf, int size) -> transfer_control"""
    return _ftdi1.read_data_submit(ftdi, buf, size)

def transfer_data_done(tc):
    r"""transfer_data_done(transfer_control tc) -> int"""
    return _ftdi1.transfer_data_done(tc)

def transfer_data_cancel(tc, to):
    r"""transfer_data_cancel(transfer_control tc, struct timeval * to)"""
    return _ftdi1.transfer_data_cancel(tc, to)

def set_bitmode(ftdi, bitmask, mode):
    r"""set_bitmode(context ftdi, unsigned char bitmask, unsigned char mode) -> int"""
    return _ftdi1.set_bitmode(ftdi, bitmask, mode)

def disable_bitbang(ftdi):
    r"""disable_bitbang(context ftdi) -> int"""
    return _ftdi1.disable_bitbang(ftdi)

def set_latency_timer(ftdi, latency):
    r"""set_latency_timer(context ftdi, unsigned char latency) -> int"""
    return _ftdi1.set_latency_timer(ftdi, latency)

def setflowctrl(ftdi, flowctrl):
    r"""setflowctrl(context ftdi, int flowctrl) -> int"""
    return _ftdi1.setflowctrl(ftdi, flowctrl)

def setflowctrl_xonxoff(ftdi, xon, xoff):
    r"""setflowctrl_xonxoff(context ftdi, unsigned char xon, unsigned char xoff) -> int"""
    return _ftdi1.setflowctrl_xonxoff(ftdi, xon, xoff)

def setdtr_rts(ftdi, dtr, rts):
    r"""setdtr_rts(context ftdi, int dtr, int rts) -> int"""
    return _ftdi1.setdtr_rts(ftdi, dtr, rts)

def setdtr(ftdi, state):
    r"""setdtr(context ftdi, int state) -> int"""
    return _ftdi1.setdtr(ftdi, state)

def setrts(ftdi, state):
    r"""setrts(context ftdi, int state) -> int"""
    return _ftdi1.setrts(ftdi, state)

def set_event_char(ftdi, eventch, enable):
    r"""set_event_char(context ftdi, unsigned char eventch, unsigned char enable) -> int"""
    return _ftdi1.set_event_char(ftdi, eventch, enable)

def set_error_char(ftdi, errorch, enable):
    r"""set_error_char(context ftdi, unsigned char errorch, unsigned char enable) -> int"""
    return _ftdi1.set_error_char(ftdi, errorch, enable)

def eeprom_initdefaults(ftdi, manufacturer, product, serial):
    r"""eeprom_initdefaults(context ftdi, char * manufacturer, char * product, char * serial) -> int"""
    return _ftdi1.eeprom_initdefaults(ftdi, manufacturer, product, serial)

def eeprom_build(ftdi):
    r"""eeprom_build(context ftdi) -> int"""
    return _ftdi1.eeprom_build(ftdi)

def eeprom_decode(ftdi, verbose):
    r"""eeprom_decode(context ftdi, int verbose) -> int"""
    return _ftdi1.eeprom_decode(ftdi, verbose)

def set_eeprom_value(ftdi, value_name, value):
    r"""set_eeprom_value(context ftdi, enum ftdi_eeprom_value value_name, int value) -> int"""
    return _ftdi1.set_eeprom_value(ftdi, value_name, value)

def set_eeprom_buf(ftdi, buf, size):
    r"""set_eeprom_buf(context ftdi, unsigned char const * buf, int size) -> int"""
    return _ftdi1.set_eeprom_buf(ftdi, buf, size)

def set_eeprom_user_data(ftdi, buf, size):
    r"""set_eeprom_user_data(context ftdi, char const * buf, int size) -> int"""
    return _ftdi1.set_eeprom_user_data(ftdi, buf, size)

def read_eeprom(ftdi):
    r"""read_eeprom(context) -> (return_code, eeprom)"""
    return _ftdi1.read_eeprom(ftdi)

def write_eeprom(ftdi):
    r"""write_eeprom(context ftdi) -> int"""
    return _ftdi1.write_eeprom(ftdi)

def erase_eeprom(ftdi):
    r"""erase_eeprom(context ftdi) -> int"""
    return _ftdi1.erase_eeprom(ftdi)

def write_eeprom_location(ftdi, eeprom_addr, eeprom_val):
    r"""write_eeprom_location(context ftdi, int eeprom_addr, unsigned short eeprom_val) -> int"""
    return _ftdi1.write_eeprom_location(ftdi, eeprom_addr, eeprom_val)

def get_error_string(ftdi):
    r"""get_error_string(context ftdi) -> char const *"""
    return _ftdi1.get_error_string(ftdi)
FTDI_MAX_EEPROM_SIZE = _ftdi1.FTDI_MAX_EEPROM_SIZE

MAX_POWER_MILLIAMP_PER_UNIT = _ftdi1.MAX_POWER_MILLIAMP_PER_UNIT

class eeprom(object):
    r"""Proxy of C ftdi_eeprom struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    vendor_id = property(_ftdi1.eeprom_vendor_id_get, _ftdi1.eeprom_vendor_id_set, doc=r"""vendor_id : int""")
    product_id = property(_ftdi1.eeprom_product_id_get, _ftdi1.eeprom_product_id_set, doc=r"""product_id : int""")
    initialized_for_connected_device = property(_ftdi1.eeprom_initialized_for_connected_device_get, _ftdi1.eeprom_initialized_for_connected_device_set, doc=r"""initialized_for_connected_device : int""")
    self_powered = property(_ftdi1.eeprom_self_powered_get, _ftdi1.eeprom_self_powered_set, doc=r"""self_powered : int""")
    remote_wakeup = property(_ftdi1.eeprom_remote_wakeup_get, _ftdi1.eeprom_remote_wakeup_set, doc=r"""remote_wakeup : int""")
    is_not_pnp = property(_ftdi1.eeprom_is_not_pnp_get, _ftdi1.eeprom_is_not_pnp_set, doc=r"""is_not_pnp : int""")
    suspend_dbus7 = property(_ftdi1.eeprom_suspend_dbus7_get, _ftdi1.eeprom_suspend_dbus7_set, doc=r"""suspend_dbus7 : int""")
    in_is_isochronous = property(_ftdi1.eeprom_in_is_isochronous_get, _ftdi1.eeprom_in_is_isochronous_set, doc=r"""in_is_isochronous : int""")
    out_is_isochronous = property(_ftdi1.eeprom_out_is_isochronous_get, _ftdi1.eeprom_out_is_isochronous_set, doc=r"""out_is_isochronous : int""")
    suspend_pull_downs = property(_ftdi1.eeprom_suspend_pull_downs_get, _ftdi1.eeprom_suspend_pull_downs_set, doc=r"""suspend_pull_downs : int""")
    use_serial = property(_ftdi1.eeprom_use_serial_get, _ftdi1.eeprom_use_serial_set, doc=r"""use_serial : int""")
    usb_version = property(_ftdi1.eeprom_usb_version_get, _ftdi1.eeprom_usb_version_set, doc=r"""usb_version : int""")
    use_usb_version = property(_ftdi1.eeprom_use_usb_version_get, _ftdi1.eeprom_use_usb_version_set, doc=r"""use_usb_version : int""")
    max_power = property(_ftdi1.eeprom_max_power_get, _ftdi1.eeprom_max_power_set, doc=r"""max_power : int""")
    manufacturer = property(_ftdi1.eeprom_manufacturer_get, _ftdi1.eeprom_manufacturer_set, doc=r"""manufacturer : p.char""")
    product = property(_ftdi1.eeprom_product_get, _ftdi1.eeprom_product_set, doc=r"""product : p.char""")
    serial = property(_ftdi1.eeprom_serial_get, _ftdi1.eeprom_serial_set, doc=r"""serial : p.char""")
    channel_a_type = property(_ftdi1.eeprom_channel_a_type_get, _ftdi1.eeprom_channel_a_type_set, doc=r"""channel_a_type : int""")
    channel_b_type = property(_ftdi1.eeprom_channel_b_type_get, _ftdi1.eeprom_channel_b_type_set, doc=r"""channel_b_type : int""")
    channel_a_driver = property(_ftdi1.eeprom_channel_a_driver_get, _ftdi1.eeprom_channel_a_driver_set, doc=r"""channel_a_driver : int""")
    channel_b_driver = property(_ftdi1.eeprom_channel_b_driver_get, _ftdi1.eeprom_channel_b_driver_set, doc=r"""channel_b_driver : int""")
    channel_c_driver = property(_ftdi1.eeprom_channel_c_driver_get, _ftdi1.eeprom_channel_c_driver_set, doc=r"""channel_c_driver : int""")
    channel_d_driver = property(_ftdi1.eeprom_channel_d_driver_get, _ftdi1.eeprom_channel_d_driver_set, doc=r"""channel_d_driver : int""")
    channel_a_rs485enable = property(_ftdi1.eeprom_channel_a_rs485enable_get, _ftdi1.eeprom_channel_a_rs485enable_set, doc=r"""channel_a_rs485enable : int""")
    channel_b_rs485enable = property(_ftdi1.eeprom_channel_b_rs485enable_get, _ftdi1.eeprom_channel_b_rs485enable_set, doc=r"""channel_b_rs485enable : int""")
    channel_c_rs485enable = property(_ftdi1.eeprom_channel_c_rs485enable_get, _ftdi1.eeprom_channel_c_rs485enable_set, doc=r"""channel_c_rs485enable : int""")
    channel_d_rs485enable = property(_ftdi1.eeprom_channel_d_rs485enable_get, _ftdi1.eeprom_channel_d_rs485enable_set, doc=r"""channel_d_rs485enable : int""")
    cbus_function = property(_ftdi1.eeprom_cbus_function_get, _ftdi1.eeprom_cbus_function_set, doc=r"""cbus_function : a(10).int""")
    high_current = property(_ftdi1.eeprom_high_current_get, _ftdi1.eeprom_high_current_set, doc=r"""high_current : int""")
    high_current_a = property(_ftdi1.eeprom_high_current_a_get, _ftdi1.eeprom_high_current_a_set, doc=r"""high_current_a : int""")
    high_current_b = property(_ftdi1.eeprom_high_current_b_get, _ftdi1.eeprom_high_current_b_set, doc=r"""high_current_b : int""")
    invert = property(_ftdi1.eeprom_invert_get, _ftdi1.eeprom_invert_set, doc=r"""invert : int""")
    external_oscillator = property(_ftdi1.eeprom_external_oscillator_get, _ftdi1.eeprom_external_oscillator_set, doc=r"""external_oscillator : int""")
    group0_drive = property(_ftdi1.eeprom_group0_drive_get, _ftdi1.eeprom_group0_drive_set, doc=r"""group0_drive : int""")
    group0_schmitt = property(_ftdi1.eeprom_group0_schmitt_get, _ftdi1.eeprom_group0_schmitt_set, doc=r"""group0_schmitt : int""")
    group0_slew = property(_ftdi1.eeprom_group0_slew_get, _ftdi1.eeprom_group0_slew_set, doc=r"""group0_slew : int""")
    group1_drive = property(_ftdi1.eeprom_group1_drive_get, _ftdi1.eeprom_group1_drive_set, doc=r"""group1_drive : int""")
    group1_schmitt = property(_ftdi1.eeprom_group1_schmitt_get, _ftdi1.eeprom_group1_schmitt_set, doc=r"""group1_schmitt : int""")
    group1_slew = property(_ftdi1.eeprom_group1_slew_get, _ftdi1.eeprom_group1_slew_set, doc=r"""group1_slew : int""")
    group2_drive = property(_ftdi1.eeprom_group2_drive_get, _ftdi1.eeprom_group2_drive_set, doc=r"""group2_drive : int""")
    group2_schmitt = property(_ftdi1.eeprom_group2_schmitt_get, _ftdi1.eeprom_group2_schmitt_set, doc=r"""group2_schmitt : int""")
    group2_slew = property(_ftdi1.eeprom_group2_slew_get, _ftdi1.eeprom_group2_slew_set, doc=r"""group2_slew : int""")
    group3_drive = property(_ftdi1.eeprom_group3_drive_get, _ftdi1.eeprom_group3_drive_set, doc=r"""group3_drive : int""")
    group3_schmitt = property(_ftdi1.eeprom_group3_schmitt_get, _ftdi1.eeprom_group3_schmitt_set, doc=r"""group3_schmitt : int""")
    group3_slew = property(_ftdi1.eeprom_group3_slew_get, _ftdi1.eeprom_group3_slew_set, doc=r"""group3_slew : int""")
    powersave = property(_ftdi1.eeprom_powersave_get, _ftdi1.eeprom_powersave_set, doc=r"""powersave : int""")
    clock_polarity = property(_ftdi1.eeprom_clock_polarity_get, _ftdi1.eeprom_clock_polarity_set, doc=r"""clock_polarity : int""")
    data_order = property(_ftdi1.eeprom_data_order_get, _ftdi1.eeprom_data_order_set, doc=r"""data_order : int""")
    flow_control = property(_ftdi1.eeprom_flow_control_get, _ftdi1.eeprom_flow_control_set, doc=r"""flow_control : int""")
    user_data_addr = property(_ftdi1.eeprom_user_data_addr_get, _ftdi1.eeprom_user_data_addr_set, doc=r"""user_data_addr : int""")
    user_data_size = property(_ftdi1.eeprom_user_data_size_get, _ftdi1.eeprom_user_data_size_set, doc=r"""user_data_size : int""")
    user_data = property(_ftdi1.eeprom_user_data_get, _ftdi1.eeprom_user_data_set, doc=r"""user_data : p.q(const).char""")
    size = property(_ftdi1.eeprom_size_get, _ftdi1.eeprom_size_set, doc=r"""size : int""")
    chip = property(_ftdi1.eeprom_chip_get, _ftdi1.eeprom_chip_set, doc=r"""chip : int""")
    buf = property(_ftdi1.eeprom_buf_get, _ftdi1.eeprom_buf_set, doc=r"""buf : a(256).unsigned char""")
    release_number = property(_ftdi1.eeprom_release_number_get, _ftdi1.eeprom_release_number_set, doc=r"""release_number : int""")

    def __init__(self):
        r"""__init__(eeprom self) -> eeprom"""
        _ftdi1.eeprom_swiginit(self, _ftdi1.new_eeprom())
    __swig_destroy__ = _ftdi1.delete_eeprom

# Register eeprom in _ftdi1:
_ftdi1.eeprom_swigregister(eeprom)

__version__ = get_library_version().version_str


