# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.38
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        try:
            fp, pathname, description = imp.find_module('_imobiledevice', [dirname(__file__)])
            _mod = imp.load_module('_imobiledevice', fp, pathname, description)
        finally:
            if fp is not None: fp.close()
        return _mod
    _imobiledevice = swig_import_helper()
    del swig_import_helper
else:
    import _imobiledevice
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _imobiledevice.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(self) -> PyObject"""
        return _imobiledevice.SwigPyIterator_value(self)

    def incr(self, n = 1):
        """
        incr(self, size_t n = 1) -> SwigPyIterator
        incr(self) -> SwigPyIterator
        """
        return _imobiledevice.SwigPyIterator_incr(self, n)

    def decr(self, n = 1):
        """
        decr(self, size_t n = 1) -> SwigPyIterator
        decr(self) -> SwigPyIterator
        """
        return _imobiledevice.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(self, SwigPyIterator x) -> ptrdiff_t"""
        return _imobiledevice.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(self, SwigPyIterator x) -> bool"""
        return _imobiledevice.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(self) -> SwigPyIterator"""
        return _imobiledevice.SwigPyIterator_copy(self)

    def next(self):
        """next(self) -> PyObject"""
        return _imobiledevice.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(self) -> PyObject"""
        return _imobiledevice.SwigPyIterator___next__(self)

    def previous(self):
        """previous(self) -> PyObject"""
        return _imobiledevice.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(self, ptrdiff_t n) -> SwigPyIterator"""
        return _imobiledevice.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SwigPyIterator x) -> bool"""
        return _imobiledevice.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SwigPyIterator x) -> bool"""
        return _imobiledevice.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _imobiledevice.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _imobiledevice.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _imobiledevice.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> SwigPyIterator
        __sub__(self, SwigPyIterator x) -> ptrdiff_t
        """
        return _imobiledevice.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _imobiledevice.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class PairStringNodePtr(_object):
    """Proxy of C++ std::pair<(std::string,p.PList::Node)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairStringNodePtr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PairStringNodePtr, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> PairStringNodePtr
        __init__(self, string __a, Node __b) -> PairStringNodePtr
        __init__(self, PairStringNodePtr __p) -> PairStringNodePtr
        """
        this = _imobiledevice.new_PairStringNodePtr(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["first"] = _imobiledevice.PairStringNodePtr_first_set
    __swig_getmethods__["first"] = _imobiledevice.PairStringNodePtr_first_get
    if _newclass:first = _swig_property(_imobiledevice.PairStringNodePtr_first_get, _imobiledevice.PairStringNodePtr_first_set)
    __swig_setmethods__["second"] = _imobiledevice.PairStringNodePtr_second_set
    __swig_getmethods__["second"] = _imobiledevice.PairStringNodePtr_second_get
    if _newclass:second = _swig_property(_imobiledevice.PairStringNodePtr_second_get, _imobiledevice.PairStringNodePtr_second_set)
    def __len__(self): return 2
    def __repr__(self): return str((self.first, self.second))
    def __getitem__(self, index): 
      if not (index % 2): 
        return self.first
      else:
        return self.second
    def __setitem__(self, index, val):
      if not (index % 2): 
        self.first = val
      else:
        self.second = val
    __swig_destroy__ = _imobiledevice.delete_PairStringNodePtr
    __del__ = lambda self : None;
PairStringNodePtr_swigregister = _imobiledevice.PairStringNodePtr_swigregister
PairStringNodePtr_swigregister(PairStringNodePtr)

class MapStringNodePtr(_object):
    """Proxy of C++ std::map<(std::string,p.PList::Node)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringNodePtr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringNodePtr, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _imobiledevice.MapStringNodePtr_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _imobiledevice.MapStringNodePtr___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _imobiledevice.MapStringNodePtr___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _imobiledevice.MapStringNodePtr___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _imobiledevice.MapStringNodePtr___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _imobiledevice.MapStringNodePtr___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _imobiledevice.MapStringNodePtr_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _imobiledevice.MapStringNodePtr_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _imobiledevice.MapStringNodePtr_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _imobiledevice.MapStringNodePtr_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _imobiledevice.MapStringNodePtr___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> SwigPyIterator"""
        return _imobiledevice.MapStringNodePtr_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> SwigPyIterator"""
        return _imobiledevice.MapStringNodePtr_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _imobiledevice.MapStringNodePtr___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> MapStringNodePtr
        __init__(self) -> MapStringNodePtr
        __init__(self, MapStringNodePtr arg0) -> MapStringNodePtr
        """
        this = _imobiledevice.new_MapStringNodePtr(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _imobiledevice.MapStringNodePtr_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _imobiledevice.MapStringNodePtr_size(self)

    def clear(self):
        """clear(self)"""
        return _imobiledevice.MapStringNodePtr_clear(self)

    def swap(self, *args):
        """swap(self, MapStringNodePtr v)"""
        return _imobiledevice.MapStringNodePtr_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _imobiledevice.MapStringNodePtr_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _imobiledevice.MapStringNodePtr_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _imobiledevice.MapStringNodePtr_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _imobiledevice.MapStringNodePtr_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _imobiledevice.MapStringNodePtr_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _imobiledevice.MapStringNodePtr_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _imobiledevice.MapStringNodePtr_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _imobiledevice.MapStringNodePtr_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _imobiledevice.MapStringNodePtr_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _imobiledevice.MapStringNodePtr_upper_bound(self, *args)

    __swig_destroy__ = _imobiledevice.delete_MapStringNodePtr
    __del__ = lambda self : None;
MapStringNodePtr_swigregister = _imobiledevice.MapStringNodePtr_swigregister
MapStringNodePtr_swigregister(MapStringNodePtr)

class Node(_object):
    """Proxy of C++ PList::Node class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Node, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Node, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _imobiledevice.delete_Node
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _imobiledevice.Node___deepcopy__(self)

    def GetParent(self):
        """GetParent(self) -> Node"""
        return _imobiledevice.Node_GetParent(self)

    def get_type(self):
        """get_type(self) -> plist_type"""
        return _imobiledevice.Node_get_type(self)

    def FromPlist(*args):
        """
        FromPlist(plist_t node, Node parent = None) -> Node
        FromPlist(plist_t node) -> Node
        """
        return _imobiledevice.Node_FromPlist(*args)

    if _newclass:FromPlist = staticmethod(FromPlist)
    __swig_getmethods__["FromPlist"] = lambda x: FromPlist
Node_swigregister = _imobiledevice.Node_swigregister
Node_swigregister(Node)

def Node_FromPlist(*args):
  """
    FromPlist(plist_t node, Node parent = None) -> Node
    Node_FromPlist(plist_t node) -> Node
    """
  return _imobiledevice.Node_FromPlist(*args)

class Boolean(Node):
    """Proxy of C++ PList::Boolean class"""
    __swig_setmethods__ = {}
    for _s in [Node]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Boolean, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Boolean, name)
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Boolean b) -> Boolean"""
        return _imobiledevice.Boolean___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Boolean
        __init__(self) -> Boolean
        __init__(self, plist_t node, Node parent = None) -> Boolean
        __init__(self, Boolean b) -> Boolean
        __init__(self, bool b) -> Boolean
        """
        this = _imobiledevice.new_Boolean(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_Boolean
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _imobiledevice.Boolean___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, bool b)"""
        return _imobiledevice.Boolean_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> bool"""
        return _imobiledevice.Boolean_get_value(self)

Boolean_swigregister = _imobiledevice.Boolean_swigregister
Boolean_swigregister(Boolean)

class Integer(Node):
    """Proxy of C++ PList::Integer class"""
    __swig_setmethods__ = {}
    for _s in [Node]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Integer, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Integer, name)
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Integer i) -> Integer"""
        return _imobiledevice.Integer___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Integer
        __init__(self) -> Integer
        __init__(self, plist_t node, Node parent = None) -> Integer
        __init__(self, Integer i) -> Integer
        __init__(self, uint64_t i) -> Integer
        """
        this = _imobiledevice.new_Integer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_Integer
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _imobiledevice.Integer___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, uint64_t i)"""
        return _imobiledevice.Integer_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> uint64_t"""
        return _imobiledevice.Integer_get_value(self)

Integer_swigregister = _imobiledevice.Integer_swigregister
Integer_swigregister(Integer)

class Real(Node):
    """Proxy of C++ PList::Real class"""
    __swig_setmethods__ = {}
    for _s in [Node]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Real, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Real, name)
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Real d) -> Real"""
        return _imobiledevice.Real___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Real
        __init__(self) -> Real
        __init__(self, plist_t node, Node parent = None) -> Real
        __init__(self, Real d) -> Real
        __init__(self, double d) -> Real
        """
        this = _imobiledevice.new_Real(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_Real
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _imobiledevice.Real___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, double d)"""
        return _imobiledevice.Real_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> double"""
        return _imobiledevice.Real_get_value(self)

Real_swigregister = _imobiledevice.Real_swigregister
Real_swigregister(Real)

class String(Node):
    """Proxy of C++ PList::String class"""
    __swig_setmethods__ = {}
    for _s in [Node]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, String, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, String, name)
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, String s) -> String"""
        return _imobiledevice.String___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> String
        __init__(self) -> String
        __init__(self, plist_t node, Node parent = None) -> String
        __init__(self, String s) -> String
        __init__(self, string s) -> String
        """
        this = _imobiledevice.new_String(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_String
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _imobiledevice.String___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, string s)"""
        return _imobiledevice.String_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> string"""
        return _imobiledevice.String_get_value(self)

String_swigregister = _imobiledevice.String_swigregister
String_swigregister(String)

class Data(Node):
    """Proxy of C++ PList::Data class"""
    __swig_setmethods__ = {}
    for _s in [Node]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Data, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Data, name)
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Data d) -> Data"""
        return _imobiledevice.Data___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Data
        __init__(self) -> Data
        __init__(self, plist_t node, Node parent = None) -> Data
        __init__(self, Data d) -> Data
        __init__(self, std::vector<(char)> buff) -> Data
        """
        this = _imobiledevice.new_Data(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_Data
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _imobiledevice.Data___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, std::vector<(char)> buff)"""
        return _imobiledevice.Data_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> std::vector<(char)>"""
        return _imobiledevice.Data_get_value(self)

Data_swigregister = _imobiledevice.Data_swigregister
Data_swigregister(Data)

class Date(Node):
    """Proxy of C++ PList::Date class"""
    __swig_setmethods__ = {}
    for _s in [Node]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Date, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Date, name)
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Date d) -> Date"""
        return _imobiledevice.Date___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Date
        __init__(self) -> Date
        __init__(self, plist_t node, Node parent = None) -> Date
        __init__(self, Date d) -> Date
        __init__(self, timeval t) -> Date
        """
        this = _imobiledevice.new_Date(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_Date
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _imobiledevice.Date___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, timeval t)"""
        return _imobiledevice.Date_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> timeval"""
        return _imobiledevice.Date_get_value(self)

Date_swigregister = _imobiledevice.Date_swigregister
Date_swigregister(Date)

class Structure(Node):
    """Proxy of C++ PList::Structure class"""
    __swig_setmethods__ = {}
    for _s in [Node]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Structure, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Structure, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _imobiledevice.delete_Structure
    __del__ = lambda self : None;
    def __len__(self):
        """__len__(self) -> uint32_t"""
        return _imobiledevice.Structure___len__(self)

    def to_xml(self):
        """to_xml(self) -> string"""
        return _imobiledevice.Structure_to_xml(self)

    def to_bin(self):
        """to_bin(self) -> std::vector<(char)>"""
        return _imobiledevice.Structure_to_bin(self)

    def __delitem__(self, *args):
        """__delitem__(self, Node node)"""
        return _imobiledevice.Structure___delitem__(self, *args)

    def from_xml(*args):
        """from_xml(string xml) -> Structure"""
        return _imobiledevice.Structure_from_xml(*args)

    if _newclass:from_xml = staticmethod(from_xml)
    __swig_getmethods__["from_xml"] = lambda x: from_xml
    def from_bin(*args):
        """from_bin(std::vector<(char)> bin) -> Structure"""
        return _imobiledevice.Structure_from_bin(*args)

    if _newclass:from_bin = staticmethod(from_bin)
    __swig_getmethods__["from_bin"] = lambda x: from_bin
Structure_swigregister = _imobiledevice.Structure_swigregister
Structure_swigregister(Structure)

def Structure_from_xml(*args):
  """Structure_from_xml(string xml) -> Structure"""
  return _imobiledevice.Structure_from_xml(*args)

def Structure_from_bin(*args):
  """Structure_from_bin(std::vector<(char)> bin) -> Structure"""
  return _imobiledevice.Structure_from_bin(*args)

class Array(Structure):
    """Proxy of C++ PList::Array class"""
    __swig_setmethods__ = {}
    for _s in [Structure]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Array, name, value)
    __swig_getmethods__ = {}
    for _s in [Structure]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Array, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Array
        __init__(self) -> Array
        __init__(self, plist_t node, Node parent = None) -> Array
        __init__(self, Array a) -> Array
        """
        this = _imobiledevice.new_Array(*args)
        try: self.this.append(this)
        except: self.this = this
    def __assign__(self, *args):
        """__assign__(self, Array a) -> Array"""
        return _imobiledevice.Array___assign__(self, *args)

    __swig_destroy__ = _imobiledevice.delete_Array
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _imobiledevice.Array___deepcopy__(self)

    def __getitem__(self, *args):
        """__getitem__(self, unsigned int index) -> Node"""
        return _imobiledevice.Array___getitem__(self, *args)

    def append(self, *args):
        """append(self, Node node)"""
        return _imobiledevice.Array_append(self, *args)

    def insert(self, *args):
        """insert(self, Node node, unsigned int pos)"""
        return _imobiledevice.Array_insert(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, Node node)
        __delitem__(self, unsigned int pos)
        """
        return _imobiledevice.Array___delitem__(self, *args)

    def GetNodeIndex(self, *args):
        """GetNodeIndex(self, Node node) -> unsigned int"""
        return _imobiledevice.Array_GetNodeIndex(self, *args)

Array_swigregister = _imobiledevice.Array_swigregister
Array_swigregister(Array)

class Dictionary(Structure):
    """Proxy of C++ PList::Dictionary class"""
    __swig_setmethods__ = {}
    for _s in [Structure]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dictionary, name, value)
    __swig_getmethods__ = {}
    for _s in [Structure]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Dictionary, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Dictionary
        __init__(self) -> Dictionary
        __init__(self, plist_t node, Node parent = None) -> Dictionary
        __init__(self, Dictionary d) -> Dictionary
        """
        this = _imobiledevice.new_Dictionary(*args)
        try: self.this.append(this)
        except: self.this = this
    def __assign__(self, *args):
        """__assign__(self, Dictionary d) -> Dictionary"""
        return _imobiledevice.Dictionary___assign__(self, *args)

    __swig_destroy__ = _imobiledevice.delete_Dictionary
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _imobiledevice.Dictionary___deepcopy__(self)

    def __getitem__(self, *args):
        """__getitem__(self, string key) -> Node"""
        return _imobiledevice.Dictionary___getitem__(self, *args)

    def Find(self, *args):
        """Find(self, string key) -> iterator"""
        return _imobiledevice.Dictionary_Find(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, string key, Node node) -> iterator"""
        return _imobiledevice.Dictionary___setitem__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, Node node)
        __delitem__(self, string key)
        """
        return _imobiledevice.Dictionary___delitem__(self, *args)

    def GetNodeKey(self, *args):
        """GetNodeKey(self, Node key) -> string"""
        return _imobiledevice.Dictionary_GetNodeKey(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> SwigPyIterator"""
        return _imobiledevice.Dictionary_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> SwigPyIterator"""
        return _imobiledevice.Dictionary_value_iterator(self)

    def iteritems(self):
        """iteritems(self) -> iterator"""
        return _imobiledevice.Dictionary_iteritems(self)

    def has_key(self, *args):
        """has_key(self, string key) -> bool"""
        return _imobiledevice.Dictionary_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _imobiledevice.Dictionary_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _imobiledevice.Dictionary_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _imobiledevice.Dictionary_items(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
Dictionary_swigregister = _imobiledevice.Dictionary_swigregister
Dictionary_swigregister(Dictionary)

PLIST_BOOLEAN = _imobiledevice.PLIST_BOOLEAN
PLIST_UINT = _imobiledevice.PLIST_UINT
PLIST_REAL = _imobiledevice.PLIST_REAL
PLIST_STRING = _imobiledevice.PLIST_STRING
PLIST_ARRAY = _imobiledevice.PLIST_ARRAY
PLIST_DICT = _imobiledevice.PLIST_DICT
PLIST_DATE = _imobiledevice.PLIST_DATE
PLIST_DATA = _imobiledevice.PLIST_DATA
PLIST_KEY = _imobiledevice.PLIST_KEY
PLIST_NONE = _imobiledevice.PLIST_NONE
class idevice(_object):
    """Proxy of C++ idevice class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, idevice, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, idevice, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dev"] = _imobiledevice.idevice_dev_set
    __swig_getmethods__["dev"] = _imobiledevice.idevice_dev_get
    if _newclass:dev = _swig_property(_imobiledevice.idevice_dev_get, _imobiledevice.idevice_dev_set)
    def __init__(self): 
        """__init__(self) -> idevice"""
        this = _imobiledevice.new_idevice()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_idevice
    __del__ = lambda self : None;
    def set_debug_level(self, *args):
        """set_debug_level(self, int level)"""
        return _imobiledevice.idevice_set_debug_level(self, *args)

    def init_device_by_uuid(self, *args):
        """init_device_by_uuid(self, char uuid) -> int"""
        return _imobiledevice.idevice_init_device_by_uuid(self, *args)

    def init_device(self):
        """init_device(self) -> int"""
        return _imobiledevice.idevice_init_device(self)

    def get_uuid(self):
        """get_uuid(self) -> char"""
        return _imobiledevice.idevice_get_uuid(self)

    def get_lockdown_client(self):
        """get_lockdown_client(self) -> Lockdownd"""
        return _imobiledevice.idevice_get_lockdown_client(self)

idevice_swigregister = _imobiledevice.idevice_swigregister
idevice_swigregister(idevice)

class Lockdownd(_object):
    """Proxy of C++ Lockdownd class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Lockdownd, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Lockdownd, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dev"] = _imobiledevice.Lockdownd_dev_set
    __swig_getmethods__["dev"] = _imobiledevice.Lockdownd_dev_get
    if _newclass:dev = _swig_property(_imobiledevice.Lockdownd_dev_get, _imobiledevice.Lockdownd_dev_set)
    __swig_setmethods__["client"] = _imobiledevice.Lockdownd_client_set
    __swig_getmethods__["client"] = _imobiledevice.Lockdownd_client_get
    if _newclass:client = _swig_property(_imobiledevice.Lockdownd_client_get, _imobiledevice.Lockdownd_client_set)
    def __init__(self, *args): 
        """__init__(self, idevice device) -> Lockdownd"""
        this = _imobiledevice.new_Lockdownd(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_Lockdownd
    __del__ = lambda self : None;
    def send(self, *args):
        """send(self, Node node)"""
        return _imobiledevice.Lockdownd_send(self, *args)

    def receive(self):
        """receive(self) -> Node"""
        return _imobiledevice.Lockdownd_receive(self)

    def get_mobilesync_client(self):
        """get_mobilesync_client(self) -> MobileSync"""
        return _imobiledevice.Lockdownd_get_mobilesync_client(self)

    def get_notification_proxy_client(self):
        """get_notification_proxy_client(self) -> NotificationProxy"""
        return _imobiledevice.Lockdownd_get_notification_proxy_client(self)

Lockdownd_swigregister = _imobiledevice.Lockdownd_swigregister
Lockdownd_swigregister(Lockdownd)

class MobileSync(_object):
    """Proxy of C++ MobileSync class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MobileSync, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MobileSync, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dev"] = _imobiledevice.MobileSync_dev_set
    __swig_getmethods__["dev"] = _imobiledevice.MobileSync_dev_get
    if _newclass:dev = _swig_property(_imobiledevice.MobileSync_dev_get, _imobiledevice.MobileSync_dev_set)
    __swig_setmethods__["client"] = _imobiledevice.MobileSync_client_set
    __swig_getmethods__["client"] = _imobiledevice.MobileSync_client_get
    if _newclass:client = _swig_property(_imobiledevice.MobileSync_client_get, _imobiledevice.MobileSync_client_set)
    def __init__(self, *args): 
        """__init__(self, Lockdownd lckd) -> MobileSync"""
        this = _imobiledevice.new_MobileSync(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_MobileSync
    __del__ = lambda self : None;
    def send(self, *args):
        """send(self, Node node)"""
        return _imobiledevice.MobileSync_send(self, *args)

    def receive(self):
        """receive(self) -> Node"""
        return _imobiledevice.MobileSync_receive(self)

MobileSync_swigregister = _imobiledevice.MobileSync_swigregister
MobileSync_swigregister(MobileSync)

class NotificationProxy(_object):
    """Proxy of C++ NotificationProxy class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotificationProxy, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NotificationProxy, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dev"] = _imobiledevice.NotificationProxy_dev_set
    __swig_getmethods__["dev"] = _imobiledevice.NotificationProxy_dev_get
    if _newclass:dev = _swig_property(_imobiledevice.NotificationProxy_dev_get, _imobiledevice.NotificationProxy_dev_set)
    __swig_setmethods__["client"] = _imobiledevice.NotificationProxy_client_set
    __swig_getmethods__["client"] = _imobiledevice.NotificationProxy_client_get
    if _newclass:client = _swig_property(_imobiledevice.NotificationProxy_client_get, _imobiledevice.NotificationProxy_client_set)
    def __init__(self, *args): 
        """__init__(self, Lockdownd lckd) -> NotificationProxy"""
        this = _imobiledevice.new_NotificationProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _imobiledevice.delete_NotificationProxy
    __del__ = lambda self : None;
    def post_notification(self, *args):
        """post_notification(self, char notification) -> int16_t"""
        return _imobiledevice.NotificationProxy_post_notification(self, *args)

    def observe_notification(self, *args):
        """observe_notification(self, char notification) -> int16_t"""
        return _imobiledevice.NotificationProxy_observe_notification(self, *args)

    def observe_notifications(self, *args):
        """observe_notifications(self, char string_list) -> int16_t"""
        return _imobiledevice.NotificationProxy_observe_notifications(self, *args)

    def set_callback(self, *args):
        """set_callback(self, PyObject pyfunc) -> int16_t"""
        return _imobiledevice.NotificationProxy_set_callback(self, *args)

NotificationProxy_swigregister = _imobiledevice.NotificationProxy_swigregister
NotificationProxy_swigregister(NotificationProxy)

NP_SYNC_WILL_START = _imobiledevice.NP_SYNC_WILL_START
NP_SYNC_DID_START = _imobiledevice.NP_SYNC_DID_START
NP_SYNC_DID_FINISH = _imobiledevice.NP_SYNC_DID_FINISH
NP_SYNC_LOCK_REQUEST = _imobiledevice.NP_SYNC_LOCK_REQUEST


