class GGColor(object):
    @property
    def a(self):
        pass

    @property
    def r(self):
        pass

    @property
    def b(self):
        pass

    @property
    def g(self):
        pass


class IntBoolMap(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::map<int,bool,struct std::less<int>,class std::allocator<struct std::pair<int const ,bool> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::map<int,bool,struct std::less<int>,class std::allocator<struct std::pair<int const ,bool> > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::map<int,bool,struct std::less<int>,class std::allocator<struct std::pair<int const ,bool> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::map<int,bool,struct std::less<int>,class std::allocator<struct std::pair<int const ,bool> > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_iterator<class std::_Tree_val<class std::_Tmap_traits<int,bool,struct std::less<int>,class std::allocator<struct std::pair<int const ,bool> >,0> > > > __iter__(struct boost::python::back_reference<class std::map<int,bool,struct std::less<int>,class std::allocator<struct std::pair<int const ,bool> > > &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::map<int,bool,struct std::less<int>,class std::allocator<struct std::pair<int const ,bool> > > {lvalue})
        
        :rtype int
        """
        return int()


class IntDblMap(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::map<int,double,struct std::less<int>,class std::allocator<struct std::pair<int const ,double> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::map<int,double,struct std::less<int>,class std::allocator<struct std::pair<int const ,double> > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::map<int,double,struct std::less<int>,class std::allocator<struct std::pair<int const ,double> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::map<int,double,struct std::less<int>,class std::allocator<struct std::pair<int const ,double> > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_iterator<class std::_Tree_val<class std::_Tmap_traits<int,double,struct std::less<int>,class std::allocator<struct std::pair<int const ,double> >,0> > > > __iter__(struct boost::python::back_reference<class std::map<int,double,struct std::less<int>,class std::allocator<struct std::pair<int const ,double> > > &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::map<int,double,struct std::less<int>,class std::allocator<struct std::pair<int const ,double> > > {lvalue})
        
        :rtype int
        """
        return int()


class IntIntMap(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::map<int,int,struct std::less<int>,class std::allocator<struct std::pair<int const ,int> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::map<int,int,struct std::less<int>,class std::allocator<struct std::pair<int const ,int> > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::map<int,int,struct std::less<int>,class std::allocator<struct std::pair<int const ,int> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::map<int,int,struct std::less<int>,class std::allocator<struct std::pair<int const ,int> > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_iterator<class std::_Tree_val<class std::_Tmap_traits<int,int,struct std::less<int>,class std::allocator<struct std::pair<int const ,int> >,0> > > > __iter__(struct boost::python::back_reference<class std::map<int,int,struct std::less<int>,class std::allocator<struct std::pair<int const ,int> > > &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::map<int,int,struct std::less<int>,class std::allocator<struct std::pair<int const ,int> > > {lvalue})
        
        :rtype int
        """
        return int()


class IntPairVec(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::vector<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def extend(self, obj):
        """
        C++ signature:
            void extend(class std::vector<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::vector<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::vector<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Vector_iterator<class std::_Vector_val<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > > > __iter__(struct boost::python::back_reference<class std::vector<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > &>)
        
        :rtype object
        """
        return object()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::vector<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::vector<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > {lvalue})
        
        :rtype int
        """
        return int()

    def append(self, obj):
        """
        C++ signature:
            void append(class std::vector<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None


class IntSet(object):
    def count(self, number):
        """
        C++ signature:
            unsigned int count(class std::set<int,struct std::less<int>,class std::allocator<int> >,int)
        
        :param number:
        :type number: int
        :rtype int
        """
        return int()

    def __contains__(self, number):
        """
        C++ signature:
            bool __contains__(class std::set<int,struct std::less<int>,class std::allocator<int> >,int)
        
        :param number:
        :type number: int
        :rtype bool
        """
        return bool()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_const_iterator<class std::_Tree_val<class std::_Tset_traits<int,struct std::less<int>,class std::allocator<int>,0> > > > __iter__(struct boost::python::back_reference<class std::set<int,struct std::less<int>,class std::allocator<int> > &>)
        
        :rtype iter
        """
        return iter()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::set<int,struct std::less<int>,class std::allocator<int> >)
        
        :rtype int
        """
        return int()

    def empty(self):
        """
        C++ signature:
            bool empty(class std::set<int,struct std::less<int>,class std::allocator<int> >)
        
        :rtype bool
        """
        return bool()

    def size(self):
        """
        C++ signature:
            unsigned int size(class std::set<int,struct std::less<int>,class std::allocator<int> >)
        
        :rtype int
        """
        return int()


class IntSetSet(object):
    def count(self, int_set):
        """
        C++ signature:
            unsigned int count(class std::set<class std::set<int,struct std::less<int>,class std::allocator<int> >,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<class std::set<int,struct std::less<int>,class std::allocator<int> > > >,class std::set<int,struct std::less<int>,class std::allocator<int> >)
        
        :param int_set:
        :type int_set: IntSet
        :rtype int
        """
        return int()

    def __contains__(self, int_set):
        """
        C++ signature:
            bool __contains__(class std::set<class std::set<int,struct std::less<int>,class std::allocator<int> >,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<class std::set<int,struct std::less<int>,class std::allocator<int> > > >,class std::set<int,struct std::less<int>,class std::allocator<int> >)
        
        :param int_set:
        :type int_set: IntSet
        :rtype bool
        """
        return bool()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_const_iterator<class std::_Tree_val<class std::_Tset_traits<class std::set<int,struct std::less<int>,class std::allocator<int> >,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<class std::set<int,struct std::less<int>,class std::allocator<int> > >,0> > > > __iter__(struct boost::python::back_reference<class std::set<class std::set<int,struct std::less<int>,class std::allocator<int> >,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<class std::set<int,struct std::less<int>,class std::allocator<int> > > > &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::set<class std::set<int,struct std::less<int>,class std::allocator<int> >,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<class std::set<int,struct std::less<int>,class std::allocator<int> > > >)
        
        :rtype int
        """
        return int()

    def empty(self):
        """
        C++ signature:
            bool empty(class std::set<class std::set<int,struct std::less<int>,class std::allocator<int> >,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<class std::set<int,struct std::less<int>,class std::allocator<int> > > >)
        
        :rtype bool
        """
        return bool()

    def size(self):
        """
        C++ signature:
            unsigned int size(class std::set<class std::set<int,struct std::less<int>,class std::allocator<int> >,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<class std::set<int,struct std::less<int>,class std::allocator<int> > > >)
        
        :rtype int
        """
        return int()


class IntVec(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::vector<int,class std::allocator<int> > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def extend(self, obj):
        """
        C++ signature:
            void extend(class std::vector<int,class std::allocator<int> > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::vector<int,class std::allocator<int> > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::vector<int,class std::allocator<int> > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Vector_iterator<class std::_Vector_val<int,class std::allocator<int> > > > __iter__(struct boost::python::back_reference<class std::vector<int,class std::allocator<int> > &>)
        
        :rtype iter
        """
        return iter()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::vector<int,class std::allocator<int> > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::vector<int,class std::allocator<int> > {lvalue})
        
        :rtype int
        """
        return int()

    def append(self, obj):
        """
        C++ signature:
            void append(class std::vector<int,class std::allocator<int> > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None


class ItemSpecVec(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::vector<struct ItemSpec,class std::allocator<struct ItemSpec> > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def extend(self, obj):
        """
        C++ signature:
            void extend(class std::vector<struct ItemSpec,class std::allocator<struct ItemSpec> > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::vector<struct ItemSpec,class std::allocator<struct ItemSpec> > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::vector<struct ItemSpec,class std::allocator<struct ItemSpec> > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Vector_iterator<class std::_Vector_val<struct ItemSpec,class std::allocator<struct ItemSpec> > > > __iter__(struct boost::python::back_reference<class std::vector<struct ItemSpec,class std::allocator<struct ItemSpec> > &>)
        
        :rtype iter
        """
        return iter()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::vector<struct ItemSpec,class std::allocator<struct ItemSpec> > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::vector<struct ItemSpec,class std::allocator<struct ItemSpec> > {lvalue})
        
        :rtype int
        """
        return int()

    def append(self, obj):
        """
        C++ signature:
            void append(class std::vector<struct ItemSpec,class std::allocator<struct ItemSpec> > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None


class MeterTypeMeterMap(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::map<enum MeterType,class Meter,struct std::less<enum MeterType>,class std::allocator<struct std::pair<enum MeterType const ,class Meter> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::map<enum MeterType,class Meter,struct std::less<enum MeterType>,class std::allocator<struct std::pair<enum MeterType const ,class Meter> > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::map<enum MeterType,class Meter,struct std::less<enum MeterType>,class std::allocator<struct std::pair<enum MeterType const ,class Meter> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::map<enum MeterType,class Meter,struct std::less<enum MeterType>,class std::allocator<struct std::pair<enum MeterType const ,class Meter> > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_iterator<class std::_Tree_val<class std::_Tmap_traits<enum MeterType,class Meter,struct std::less<enum MeterType>,class std::allocator<struct std::pair<enum MeterType const ,class Meter> >,0> > > > __iter__(struct boost::python::back_reference<class std::map<enum MeterType,class Meter,struct std::less<enum MeterType>,class std::allocator<struct std::pair<enum MeterType const ,class Meter> > > &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::map<enum MeterType,class Meter,struct std::less<enum MeterType>,class std::allocator<struct std::pair<enum MeterType const ,class Meter> > > {lvalue})
        
        :rtype int
        """
        return int()


class MeterTypeStringPair(object):
    @property
    def meterType(self):
        pass

    @property
    def string(self):
        pass


class PairIntInt_IntMap(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::map<struct std::pair<int,int>,int,struct std::less<struct std::pair<int,int> >,class std::allocator<struct std::pair<struct std::pair<int,int> const ,int> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::map<struct std::pair<int,int>,int,struct std::less<struct std::pair<int,int> >,class std::allocator<struct std::pair<struct std::pair<int,int> const ,int> > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::map<struct std::pair<int,int>,int,struct std::less<struct std::pair<int,int> >,class std::allocator<struct std::pair<struct std::pair<int,int> const ,int> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::map<struct std::pair<int,int>,int,struct std::less<struct std::pair<int,int> >,class std::allocator<struct std::pair<struct std::pair<int,int> const ,int> > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_iterator<class std::_Tree_val<class std::_Tmap_traits<struct std::pair<int,int>,int,struct std::less<struct std::pair<int,int> >,class std::allocator<struct std::pair<struct std::pair<int,int> const ,int> >,0> > > > __iter__(struct boost::python::back_reference<class std::map<struct std::pair<int,int>,int,struct std::less<struct std::pair<int,int> >,class std::allocator<struct std::pair<struct std::pair<int,int> const ,int> > > &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::map<struct std::pair<int,int>,int,struct std::less<struct std::pair<int,int> >,class std::allocator<struct std::pair<struct std::pair<int,int> const ,int> > > {lvalue})
        
        :rtype int
        """
        return int()


class ShipPartMeterMap(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::map<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class Meter,struct std::less<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >,class std::allocator<struct std::pair<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > const ,class Meter> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::map<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class Meter,struct std::less<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >,class std::allocator<struct std::pair<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > const ,class Meter> > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::map<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class Meter,struct std::less<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >,class std::allocator<struct std::pair<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > const ,class Meter> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::map<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class Meter,struct std::less<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >,class std::allocator<struct std::pair<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > const ,class Meter> > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_internal_reference<1,struct boost::python::default_call_policies>,class std::_Tree_iterator<class std::_Tree_val<class std::_Tmap_traits<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class Meter,struct std::less<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >,class std::allocator<struct std::pair<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > const ,class Meter> >,0> > > > __iter__(struct boost::python::back_reference<class std::map<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class Meter,struct std::less<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >,class std::allocator<struct std::pair<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > const ,class Meter> > > &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::map<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class Meter,struct std::less<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >,class std::allocator<struct std::pair<struct std::pair<enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > const ,class Meter> > > {lvalue})
        
        :rtype int
        """
        return int()


class ShipSlotVec(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::vector<enum ShipSlotType,class std::allocator<enum ShipSlotType> > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def extend(self, obj):
        """
        C++ signature:
            void extend(class std::vector<enum ShipSlotType,class std::allocator<enum ShipSlotType> > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::vector<enum ShipSlotType,class std::allocator<enum ShipSlotType> > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::vector<enum ShipSlotType,class std::allocator<enum ShipSlotType> > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Vector_iterator<class std::_Vector_val<enum ShipSlotType,class std::allocator<enum ShipSlotType> > > > __iter__(struct boost::python::back_reference<class std::vector<enum ShipSlotType,class std::allocator<enum ShipSlotType> > &>)
        
        :rtype object
        """
        return object()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::vector<enum ShipSlotType,class std::allocator<enum ShipSlotType> > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::vector<enum ShipSlotType,class std::allocator<enum ShipSlotType> > {lvalue})
        
        :rtype int
        """
        return int()

    def append(self, obj):
        """
        C++ signature:
            void append(class std::vector<enum ShipSlotType,class std::allocator<enum ShipSlotType> > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None


class StringSet(object):
    def count(self, string):
        """
        C++ signature:
            unsigned int count(class std::set<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype int
        """
        return int()

    def __contains__(self, string):
        """
        C++ signature:
            bool __contains__(class std::set<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype bool
        """
        return bool()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_const_iterator<class std::_Tree_val<class std::_Tset_traits<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,0> > > > __iter__(struct boost::python::back_reference<class std::set<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > &>)
        
        :rtype iter
        """
        return iter()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::set<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >)
        
        :rtype int
        """
        return int()

    def empty(self):
        """
        C++ signature:
            bool empty(class std::set<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >)
        
        :rtype bool
        """
        return bool()

    def size(self):
        """
        C++ signature:
            unsigned int size(class std::set<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,struct std::less<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >)
        
        :rtype int
        """
        return int()


class StringVec(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def extend(self, obj):
        """
        C++ signature:
            void extend(class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Vector_iterator<class std::_Vector_val<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > > > __iter__(struct boost::python::back_reference<class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > &>)
        
        :rtype iter
        """
        return iter()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > {lvalue})
        
        :rtype int
        """
        return int()

    def append(self, obj):
        """
        C++ signature:
            void append(class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > {lvalue},class boost::python::api::object)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None


class VisibilityIntMap(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::map<enum Visibility,int,struct std::less<enum Visibility>,class std::allocator<struct std::pair<enum Visibility const ,int> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::map<enum Visibility,int,struct std::less<enum Visibility>,class std::allocator<struct std::pair<enum Visibility const ,int> > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::map<enum Visibility,int,struct std::less<enum Visibility>,class std::allocator<struct std::pair<enum Visibility const ,int> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::map<enum Visibility,int,struct std::less<enum Visibility>,class std::allocator<struct std::pair<enum Visibility const ,int> > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_iterator<class std::_Tree_val<class std::_Tmap_traits<enum Visibility,int,struct std::less<enum Visibility>,class std::allocator<struct std::pair<enum Visibility const ,int> >,0> > > > __iter__(struct boost::python::back_reference<class std::map<enum Visibility,int,struct std::less<enum Visibility>,class std::allocator<struct std::pair<enum Visibility const ,int> > > &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::map<enum Visibility,int,struct std::less<enum Visibility>,class std::allocator<struct std::pair<enum Visibility const ,int> > > {lvalue})
        
        :rtype int
        """
        return int()


class buildingType(object):
    @property
    def description(self):
        return str()

    @property
    def dump(self):
        return str()

    @property
    def name(self):
        return str()

    def canBeProduced(self, number1, number2):
        """
        C++ signature:
            bool canBeProduced(class BuildingType {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype bool
        """
        return bool()

    def perTurnCost(self, number1, number2):
        """
        C++ signature:
            float perTurnCost(class BuildingType {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype float
        """
        return float()

    def captureResult(self, number1, number2, number3, boolean):
        """
        C++ signature:
            enum CaptureResult captureResult(class BuildingType {lvalue},int,int,int,bool)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :param number3:
        :type number3: int
        :param boolean:
        :type boolean: bool
        :rtype captureResult
        """
        return captureResult()

    def productionCost(self, number1, number2):
        """
        C++ signature:
            float productionCost(class BuildingType {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype float
        """
        return float()

    def productionTime(self, number1, number2):
        """
        C++ signature:
            int productionTime(class BuildingType {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype int
        """
        return int()


class diplomaticMessage(object):
    @property
    def recipient(self):
        return int()

    @property
    def type(self):
        return diplomaticMessageType()

    @property
    def sender(self):
        return int()


class diplomaticStatusUpdate(object):
    @property
    def status(self):
        pass

    @property
    def empire2(self):
        pass

    @property
    def empire1(self):
        pass


class empire(object):
    @property
    def productionPoints(self):
        return float()

    @property
    def productionQueue(self):
        return productionQueue()

    @property
    def planetsWithWastedPP(self):
        return IntSetSet()

    @property
    def capitalID(self):
        return int()

    @property
    def playerName(self):
        return str()

    @property
    def fleetSupplyableSystemIDs(self):
        return IntSet()

    @property
    def planetsWithAllocatedPP(self):
        return resPoolMap()

    @property
    def availableShipParts(self):
        return StringSet()

    @property
    def availableBuildingTypes(self):
        return StringSet()

    @property
    def systemSupplyRanges(self):
        return IntIntMap()

    @property
    def allShipDesigns(self):
        return IntSet()

    @property
    def planetsWithAvailablePP(self):
        return resPoolMap()

    @property
    def researchQueue(self):
        return researchQueue()

    @property
    def empireID(self):
        return int()

    @property
    def name(self):
        return str()

    @property
    def colour(self):
        return GGColor()

    @property
    def availableShipHulls(self):
        return StringSet()

    @property
    def availableShipDesigns(self):
        return IntSet()

    @property
    def supplyUnobstructedSystems(self):
        return IntSet()

    @property
    def exploredSystemIDs(self):
        return IntSet()

    @property
    def availableTechs(self):
        return StringSet()

    def shipDesignAvailable(self, number):
        """
        C++ signature:
            bool shipDesignAvailable(class Empire {lvalue},int)
        
        :param number:
        :type number: int
        :rtype bool
        """
        return bool()

    def resourceAvailable(self, resource_type):
        """
        C++ signature:
            float resourceAvailable(class Empire {lvalue},enum ResourceType)
        
        :param resource_type:
        :type resource_type: resourceType
        :rtype float
        """
        return float()

    def techResearched(self, string):
        """
        C++ signature:
            bool techResearched(class Empire {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype bool
        """
        return bool()

    def resourceProduction(self, resource_type):
        """
        C++ signature:
            float resourceProduction(class Empire {lvalue},enum ResourceType)
        
        :param resource_type:
        :type resource_type: resourceType
        :rtype float
        """
        return float()

    def productionCostAndTime(self, production_queue_element):
        """
        C++ signature:
            struct std::pair<float,int> productionCostAndTime(class Empire,struct ProductionQueue::Element)
        
        :param production_queue_element:
        :type production_queue_element: productionQueueElement
        :rtype object
        """
        return object()

    def numSitReps(self, number):
        """
        C++ signature:
            int numSitReps(class Empire {lvalue},int)
        
        :param number:
        :type number: int
        :rtype int
        """
        return int()

    def getResourcePool(self, resource_type):
        """
        C++ signature:
            class boost::shared_ptr<class ResourcePool> getResourcePool(class Empire {lvalue},enum ResourceType)
        
        :param resource_type:
        :type resource_type: resourceType
        :rtype resPool
        """
        return resPool()

    def population(self):
        """
        C++ signature:
            float population(class Empire {lvalue})
        
        :rtype float
        """
        return float()

    def hasExploredSystem(self, number):
        """
        C++ signature:
            bool hasExploredSystem(class Empire {lvalue},int)
        
        :param number:
        :type number: int
        :rtype bool
        """
        return bool()

    def buildingTypeAvailable(self, string):
        """
        C++ signature:
            bool buildingTypeAvailable(class Empire {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype bool
        """
        return bool()

    def obstructedStarlanes(self):
        """
        C++ signature:
            class std::vector<struct std::pair<int,int>,class std::allocator<struct std::pair<int,int> > > obstructedStarlanes(class Empire)
        
        :rtype IntPairVec
        """
        return IntPairVec()

    def resourceStockpile(self, resource_type):
        """
        C++ signature:
            float resourceStockpile(class Empire {lvalue},enum ResourceType)
        
        :param resource_type:
        :type resource_type: resourceType
        :rtype float
        """
        return float()

    def supplyProjections(self, number, boolean):
        """
        C++ signature:
            class std::map<int,int,struct std::less<int>,class std::allocator<struct std::pair<int const ,int> > > supplyProjections(class Empire,int,bool)
        
        :param number:
        :type number: int
        :param boolean:
        :type boolean: bool
        :rtype IntIntMap
        """
        return IntIntMap()

    def canBuild(self, build_type, string, number):
        """
        C++ signatures:
            bool canBuild(class Empire {lvalue},enum BuildType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)
            bool canBuild(class Empire {lvalue},enum BuildType,int,int)
        
        :param build_type:
        :type build_type: buildType
        :param string:
        :type string: str
        :param number:
        :type number: int
        :rtype bool
        """
        return bool()

    def getSitRep(self, number):
        """
        C++ signature:
            class SitRepEntry getSitRep(class Empire,int)
        
        :param number:
        :type number: int
        :rtype sitrep
        """
        return sitrep()

    def researchProgress(self, string):
        """
        C++ signature:
            float researchProgress(class Empire {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype float
        """
        return float()

    def getTechStatus(self, string):
        """
        C++ signature:
            enum TechStatus getTechStatus(class Empire {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype techStatus
        """
        return techStatus()


class fieldType(object):
    @property
    def description(self):
        return str()

    @property
    def dump(self):
        return str()

    @property
    def name(self):
        return str()


class galaxySetupData(object):
    @property
    def age(self):
        return galaxySetupOption()

    @property
    def starlaneFrequency(self):
        return galaxySetupOption()

    @property
    def nativeFrequency(self):
        return galaxySetupOption()

    @property
    def planetDensity(self):
        return galaxySetupOption()

    @property
    def shape(self):
        return galaxyShape()

    @property
    def specialsFrequency(self):
        return galaxySetupOption()

    @property
    def monsterFrequency(self):
        return galaxySetupOption()

    @property
    def maxAIAggression(self):
        return aggression()

    @property
    def seed(self):
        return str()

    @property
    def size(self):
        return int()


class hullType(object):
    @property
    def name(self):
        return str()

    @property
    def numSlots(self):
        return int()

    @property
    def stealth(self):
        return float()

    @property
    def fuel(self):
        return float()

    @property
    def slots(self):
        return ShipSlotVec()

    @property
    def starlaneSpeed(self):
        return float()

    @property
    def structure(self):
        return float()

    def productionTime(self, number1, number2):
        """
        C++ signature:
            int productionTime(class HullType {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype int
        """
        return int()

    def numSlotsOfSlotType(self, ship_slot_type):
        """
        C++ signature:
            unsigned int numSlotsOfSlotType(class HullType {lvalue},enum ShipSlotType)
        
        :param ship_slot_type:
        :type ship_slot_type: shipSlotType
        :rtype int
        """
        return int()

    def productionCost(self, number1, number2):
        """
        C++ signature:
            float productionCost(class HullType {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype float
        """
        return float()


class itemSpec(object):
    @property
    def type(self):
        return unlockableItemType()

    @property
    def name(self):
        return str()


class meter(object):
    @property
    def current(self):
        pass

    @property
    def initial(self):
        pass

    @property
    def dump(self):
        pass


class partType(object):
    @property
    def mountableSlotTypes(self):
        return ShipSlotVec()

    @property
    def capacity(self):
        return float()

    @property
    def name(self):
        return str()

    @property
    def partClass(self):
        return shipPartClass()

    def productionCost(self, number1, number2):
        """
        C++ signature:
            float productionCost(class PartType {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype float
        """
        return float()

    def productionTime(self, number1, number2):
        """
        C++ signature:
            int productionTime(class PartType {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype int
        """
        return int()

    def canMountInSlotType(self, ship_slot_type):
        """
        C++ signature:
            bool canMountInSlotType(class PartType {lvalue},enum ShipSlotType)
        
        :param ship_slot_type:
        :type ship_slot_type: shipSlotType
        :rtype bool
        """
        return bool()


class popCenter(object):
    @property
    def nextTurnPopGrowth(self):
        pass

    @property
    def speciesName(self):
        pass


class productionQueue(object):
    @property
    def allocatedPP(self):
        return resPoolMap()

    @property
    def totalSpent(self):
        return float()

    @property
    def empireID(self):
        return int()

    @property
    def empty(self):
        return bool()

    @property
    def size(self):
        return int()

    def __getitem__(self, number):
        """
        C++ signature:
            struct ProductionQueue::Element __getitem__(struct ProductionQueue {lvalue},int)
        
        :param number:
        :type number: int
        :rtype productionQueueElement
        """
        return productionQueueElement()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Deque_iterator<struct ProductionQueue::Element,class std::allocator<struct ProductionQueue::Element> > > __iter__(struct boost::python::back_reference<struct ProductionQueue &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(struct ProductionQueue {lvalue})
        
        :rtype int
        """
        return int()

    def objectsWithWastedPP(self, res_pool):
        """
        C++ signature:
            class std::set<class std::set<int,struct std::less<int>,class std::allocator<int> >,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<class std::set<int,struct std::less<int>,class std::allocator<int> > > > objectsWithWastedPP(struct ProductionQueue {lvalue},class boost::shared_ptr<class ResourcePool>)
        
        :param res_pool:
        :type res_pool: resPool
        :rtype IntSetSet
        """
        return IntSetSet()

    def availablePP(self, res_pool):
        """
        C++ signature:
            class std::map<class std::set<int,struct std::less<int>,class std::allocator<int> >,float,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<struct std::pair<class std::set<int,struct std::less<int>,class std::allocator<int> > const ,float> > > availablePP(struct ProductionQueue {lvalue},class boost::shared_ptr<class ResourcePool>)
        
        :param res_pool:
        :type res_pool: resPool
        :rtype resPoolMap
        """
        return resPoolMap()


class productionQueueElement(object):
    @property
    def buildType(self):
        return buildType()

    @property
    def name(self):
        return str()

    @property
    def blocksize(self):
        return int()

    @property
    def turnsLeft(self):
        return int()

    @property
    def allocation(self):
        return float()

    @property
    def designID(self):
        return int()

    @property
    def locationID(self):
        return int()

    @property
    def progress(self):
        return float()

    @property
    def remaining(self):
        return int()


class resPool(object):
    pass


class resPoolMap(object):
    def __delitem__(self, obj):
        """
        C++ signature:
            void __delitem__(class std::map<class std::set<int,struct std::less<int>,class std::allocator<int> >,float,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<struct std::pair<class std::set<int,struct std::less<int>,class std::allocator<int> > const ,float> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype None
        """
        return None

    def __getitem__(self, obj2):
        """
        C++ signature:
            class boost::python::api::object __getitem__(struct boost::python::back_reference<class std::map<class std::set<int,struct std::less<int>,class std::allocator<int> >,float,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<struct std::pair<class std::set<int,struct std::less<int>,class std::allocator<int> > const ,float> > > &>,struct _object *)
        
        :param obj2:
        :type obj2: object
        :rtype object
        """
        return object()

    def __contains__(self, obj):
        """
        C++ signature:
            bool __contains__(class std::map<class std::set<int,struct std::less<int>,class std::allocator<int> >,float,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<struct std::pair<class std::set<int,struct std::less<int>,class std::allocator<int> > const ,float> > > {lvalue},struct _object *)
        
        :param obj:
        :type obj: object
        :rtype bool
        """
        return bool()

    def __setitem__(self, obj1, obj2):
        """
        C++ signature:
            void __setitem__(class std::map<class std::set<int,struct std::less<int>,class std::allocator<int> >,float,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<struct std::pair<class std::set<int,struct std::less<int>,class std::allocator<int> > const ,float> > > {lvalue},struct _object *,struct _object *)
        
        :param obj1:
        :type obj1: object
        :param obj2:
        :type obj2: object
        :rtype None
        """
        return None

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Tree_iterator<class std::_Tree_val<class std::_Tmap_traits<class std::set<int,struct std::less<int>,class std::allocator<int> >,float,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<struct std::pair<class std::set<int,struct std::less<int>,class std::allocator<int> > const ,float> >,0> > > > __iter__(struct boost::python::back_reference<class std::map<class std::set<int,struct std::less<int>,class std::allocator<int> >,float,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<struct std::pair<class std::set<int,struct std::less<int>,class std::allocator<int> > const ,float> > > &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(class std::map<class std::set<int,struct std::less<int>,class std::allocator<int> >,float,struct std::less<class std::set<int,struct std::less<int>,class std::allocator<int> > >,class std::allocator<struct std::pair<class std::set<int,struct std::less<int>,class std::allocator<int> > const ,float> > > {lvalue})
        
        :rtype int
        """
        return int()


class researchQueue(object):
    @property
    def empty(self):
        return bool()

    @property
    def totalSpent(self):
        return float()

    @property
    def empireID(self):
        return int()

    @property
    def size(self):
        return int()

    def __getitem__(self, number):
        """
        C++ signature:
            struct ResearchQueue::Element __getitem__(struct ResearchQueue {lvalue},int)
        
        :param number:
        :type number: int
        :rtype researchQueueElement
        """
        return researchQueueElement()

    def __contains__(self, research_queue_element):
        """
        C++ signature:
            bool __contains__(struct ResearchQueue const *,struct ResearchQueue::Element)
        
        :param research_queue_element:
        :type research_queue_element: researchQueueElement
        :rtype bool
        """
        return bool()

    def inQueue(self, string):
        """
        C++ signature:
            bool inQueue(struct ResearchQueue {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype bool
        """
        return bool()

    def __iter__(self):
        """
        C++ signature:
            struct boost::python::objects::iterator_range<struct boost::python::return_value_policy<struct boost::python::return_by_value,struct boost::python::default_call_policies>,class std::_Deque_iterator<struct ResearchQueue::Element,class std::allocator<struct ResearchQueue::Element> > > __iter__(struct boost::python::back_reference<struct ResearchQueue &>)
        
        :rtype object
        """
        return object()

    def __len__(self):
        """
        C++ signature:
            unsigned int __len__(struct ResearchQueue {lvalue})
        
        :rtype int
        """
        return int()


class researchQueueElement(object):
    @property
    def allocation(self):
        return float()

    @property
    def tech(self):
        return str()

    @property
    def turnsLeft(self):
        return int()


class resourceCenter(object):
    @property
    def focus(self):
        pass

    @property
    def availableFoci(self):
        pass

    @property
    def turnsSinceFocusChange(self):
        pass


class shipDesign(object):
    @property
    def isMonster(self):
        return bool()

    @property
    def defense(self):
        return float()

    @property
    def attackStats(self):
        return IntVec()

    @property
    def canColonize(self):
        return bool()

    @property
    def hull(self):
        return str()

    @property
    def isArmed(self):
        return bool()

    @property
    def id(self):
        return int()

    @property
    def canInvade(self):
        return bool()

    @property
    def attack(self):
        return float()

    @property
    def parts(self):
        return StringVec()

    @property
    def dump(self):
        return str()

    @property
    def designedOnTurn(self):
        return int()

    @property
    def starlaneSpeed(self):
        return float()

    @property
    def shields(self):
        return float()

    @property
    def structure(self):
        return float()

    def description(self, boolean):
        """
        C++ signature:
            class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > description(class ShipDesign {lvalue},bool)
        
        :param boolean:
        :type boolean: bool
        :rtype str
        """
        return str()

    def perTurnCost(self, number1, number2):
        """
        C++ signature:
            float perTurnCost(class ShipDesign {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype float
        """
        return float()

    def productionCost(self, number1, number2):
        """
        C++ signature:
            float productionCost(class ShipDesign {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype float
        """
        return float()

    def productionTime(self, number1, number2):
        """
        C++ signature:
            int productionTime(class ShipDesign {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype int
        """
        return int()

    def name(self, boolean):
        """
        C++ signature:
            class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > name(class ShipDesign {lvalue},bool)
        
        :param boolean:
        :type boolean: bool
        :rtype str
        """
        return str()

    def productionLocationForEmpire(self, number1, number2):
        """
        C++ signature:
            bool productionLocationForEmpire(class ShipDesign {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype bool
        """
        return bool()


class sitrep(object):
    @property
    def getTags(self):
        pass

    @property
    def typeString(self):
        pass

    @property
    def getTurn(self):
        return int()

    def getDataString(self, string):
        """
        C++ signature:
            class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getDataString(class SitRepEntry {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype str
        """
        return str()

    def getDataIDNumber(self, string):
        """
        C++ signature:
            int getDataIDNumber(class SitRepEntry {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype int
        """
        return int()


class special(object):
    @property
    def dump(self):
        return str()

    @property
    def spawnlimit(self):
        return int()

    @property
    def description(self):
        return str()

    @property
    def spawnrate(self):
        return float()

    @property
    def name(self):
        return str()


class species(object):
    @property
    def description(self):
        return str()

    @property
    def dump(self):
        return str()

    @property
    def tags(self):
        return StringSet()

    @property
    def canColonize(self):
        return bool()

    @property
    def name(self):
        return str()

    @property
    def foci(self):
        return StringVec()

    @property
    def canProduceShips(self):
        return bool()

    @property
    def homeworlds(self):
        return IntSet()

    @property
    def preferredFocus(self):
        return str()

    def getPlanetEnvironment(self, planet_type):
        """
        C++ signature:
            enum PlanetEnvironment getPlanetEnvironment(class Species {lvalue},enum PlanetType)
        
        :param planet_type:
        :type planet_type: planetType
        :rtype planetEnvironment
        """
        return planetEnvironment()


class tech(object):
    @property
    def category(self):
        return str()

    @property
    def unlockedItems(self):
        return ItemSpecVec()

    @property
    def description(self):
        return str()

    @property
    def shortDescription(self):
        return str()

    @property
    def unlockedTechs(self):
        return StringSet()

    @property
    def prerequisites(self):
        return StringSet()

    @property
    def type(self):
        return techType()

    @property
    def name(self):
        return str()

    def researchCost(self, number):
        """
        C++ signature:
            float researchCost(class Tech {lvalue},int)
        
        :param number:
        :type number: int
        :rtype float
        """
        return float()

    def recursivePrerequisites(self, number):
        """
        C++ signature:
            class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > recursivePrerequisites(class Tech,int)
        
        :param number:
        :type number: int
        :rtype StringVec
        """
        return StringVec()

    def perTurnCost(self, number):
        """
        C++ signature:
            float perTurnCost(class Tech {lvalue},int)
        
        :param number:
        :type number: int
        :rtype float
        """
        return float()

    def researchTime(self, number):
        """
        C++ signature:
            int researchTime(class Tech {lvalue},int)
        
        :param number:
        :type number: int
        :rtype int
        """
        return int()


class universe(object):
    @property
    def shipIDs(self):
        return IntVec()

    @property
    def fleetIDs(self):
        return IntVec()

    @property
    def planetIDs(self):
        return IntVec()

    @property
    def buildingIDs(self):
        return IntVec()

    @property
    def fieldIDs(self):
        return IntVec()

    @property
    def allObjectIDs(self):
        return IntVec()

    @property
    def systemIDs(self):
        return IntVec()

    def jumpDistance(self, number1, number2):
        """
        C++ signature:
            int jumpDistance(class Universe,int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype int
        """
        return int()

    def dump(self):
        """
        C++ signature:
            void dump(class Universe)
        
        :rtype None
        """
        return None

    def linearDistance(self, number1, number2):
        """
        C++ signature:
            double linearDistance(class Universe,int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype float
        """
        return float()

    def getObject(self, number):
        """
        C++ signature:
            class UniverseObject const * getObject(class Universe,int)
        
        :param number:
        :type number: int
        :rtype universeObject
        """
        return universeObject()

    def getPlanet(self, number):
        """
        C++ signature:
            class Planet const * getPlanet(class Universe,int)
        
        :param number:
        :type number: int
        :rtype planet
        """
        return planet()

    def getShip(self, number):
        """
        C++ signature:
            class Ship const * getShip(class Universe,int)
        
        :param number:
        :type number: int
        :rtype ship
        """
        return ship()

    def systemsConnected(self, number1, number2, number3):
        """
        C++ signature:
            bool systemsConnected(class Universe,int,int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :param number3:
        :type number3: int
        :rtype bool
        """
        return bool()

    def getVisibilityTurnsMap(self, number1, number2):
        """
        C++ signature:
            class std::map<enum Visibility,int,struct std::less<enum Visibility>,class std::allocator<struct std::pair<enum Visibility const ,int> > > getVisibilityTurnsMap(class Universe {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype VisibilityIntMap
        """
        return dict()

    def getImmediateNeighbors(self, number1, number2):
        """
        C++ signature:
            class std::vector<int,class std::allocator<int> > getImmediateNeighbors(class Universe,int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype IntVec
        """
        return IntVec()

    def getFleet(self, number):
        """
        C++ signature:
            class Fleet const * getFleet(class Universe,int)
        
        :param number:
        :type number: int
        :rtype fleet
        """
        return fleet()

    def leastJumpsPath(self, number1, number2, number3):
        """
        C++ signature:
            class std::vector<int,class std::allocator<int> > leastJumpsPath(class Universe,int,int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :param number3:
        :type number3: int
        :rtype IntVec
        """
        return IntVec()

    def updateMeterEstimates(self, item_list):
        """
        C++ signature:
            void updateMeterEstimates(class Universe,class boost::python::list)
        
        :param item_list:
        :type item_list: list
        :rtype None
        """
        return None

    def getField(self, number):
        """
        C++ signature:
            class Field const * getField(class Universe,int)
        
        :param number:
        :type number: int
        :rtype field
        """
        return field()

    def destroyedObjectIDs(self, number):
        """
        C++ signature:
            class std::set<int,struct std::less<int>,class std::allocator<int> > destroyedObjectIDs(class Universe {lvalue},int)
        
        :param number:
        :type number: int
        :rtype IntSet
        """
        return IntSet()

    def getSystemNeighborsMap(self, number1, number2):
        """
        C++ signature:
            class std::map<int,double,struct std::less<int>,class std::allocator<struct std::pair<int const ,double> > > getSystemNeighborsMap(class Universe,int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype IntDblMap
        """
        return IntDblMap()

    def systemHasStarlane(self, number1, number2):
        """
        C++ signature:
            bool systemHasStarlane(class Universe {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype bool
        """
        return bool()

    def shortestPath(self, number1, number2, number3):
        """
        C++ signature:
            class std::vector<int,class std::allocator<int> > shortestPath(class Universe,int,int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :param number3:
        :type number3: int
        :rtype IntVec
        """
        return IntVec()

    def getVisibility(self, number1, number2):
        """
        C++ signature:
            enum Visibility getVisibility(class Universe {lvalue},int,int)
        
        :param number1:
        :type number1: int
        :param number2:
        :type number2: int
        :rtype visibility
        """
        return visibility()

    def getSystem(self, number):
        """
        C++ signature:
            class System const * getSystem(class Universe,int)
        
        :param number:
        :type number: int
        :rtype system
        """
        return system()

    def getBuilding(self, number):
        """
        C++ signature:
            class Building const * getBuilding(class Universe,int)
        
        :param number:
        :type number: int
        :rtype building
        """
        return building()


class universeObject(object):
    @property
    def unowned(self):
        pass

    @property
    def meters(self):
        pass

    @property
    def owner(self):
        pass

    @property
    def id(self):
        pass

    @property
    def creationTurn(self):
        pass

    @property
    def dump(self):
        pass

    @property
    def containerObject(self):
        pass

    @property
    def containedObjects(self):
        pass

    @property
    def tags(self):
        pass

    @property
    def ageInTurns(self):
        pass

    @property
    def systemID(self):
        pass

    @property
    def name(self):
        pass

    @property
    def specials(self):
        pass

    @property
    def y(self):
        pass

    @property
    def x(self):
        pass

    def contains(self, number):
        """
        C++ signature:
            bool contains(class UniverseObject {lvalue},int)
        
        :param number:
        :type number: int
        :rtype bool
        """
        return bool()

    def nextTurnCurrentMeterValue(self, meter_type):
        """
        C++ signature:
            float nextTurnCurrentMeterValue(class UniverseObject {lvalue},enum MeterType)
        
        :param meter_type:
        :type meter_type: meterType
        :rtype float
        """
        return float()

    def initialMeterValue(self, meter_type):
        """
        C++ signature:
            float initialMeterValue(class UniverseObject {lvalue},enum MeterType)
        
        :param meter_type:
        :type meter_type: meterType
        :rtype float
        """
        return float()

    def containedBy(self, number):
        """
        C++ signature:
            bool containedBy(class UniverseObject {lvalue},int)
        
        :param number:
        :type number: int
        :rtype bool
        """
        return bool()

    def hasTag(self, string):
        """
        C++ signature:
            bool hasTag(class UniverseObject {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype bool
        """
        return bool()

    def currentMeterValue(self, meter_type):
        """
        C++ signature:
            float currentMeterValue(class UniverseObject {lvalue},enum MeterType)
        
        :param meter_type:
        :type meter_type: meterType
        :rtype float
        """
        return float()

    def specialAddedOnTurn(self, string):
        """
        C++ signature:
            int specialAddedOnTurn(class UniverseObject {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype int
        """
        return int()

    def ownedBy(self, number):
        """
        C++ signature:
            bool ownedBy(class UniverseObject {lvalue},int)
        
        :param number:
        :type number: int
        :rtype bool
        """
        return bool()

    def getMeter(self, meter_type):
        """
        C++ signature:
            class Meter const * getMeter(class UniverseObject {lvalue},enum MeterType)
        
        :param meter_type:
        :type meter_type: meterType
        :rtype meter
        """
        return meter()

    def hasSpecial(self, string):
        """
        C++ signature:
            bool hasSpecial(class UniverseObject {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype bool
        """
        return bool()


class building(universeObject):
    @property
    def buildingTypeName(self):
        return str()

    @property
    def producedByEmpireID(self):
        return int()

    @property
    def planetID(self):
        return int()

    @property
    def orderedScrapped(self):
        return bool()


class field(universeObject):
    @property
    def fieldTypeName(self):
        pass

    def inField(self, base_object):
        """
        C++ signatures:
            bool inField(class Field,class UniverseObject)
            bool inField(class Field {lvalue},double,double)
        
        :param base_object:
        :type base_object: universeObject
        :rtype bool
        """
        return bool()


class fleet(universeObject):
    @property
    def hasOutpostShips(self):
        return bool()

    @property
    def shipIDs(self):
        return IntSet()

    @property
    def hasColonyShips(self):
        return bool()

    @property
    def hasTroopShips(self):
        return bool()

    @property
    def previousSystemID(self):
        return int()

    @property
    def numShips(self):
        return int()

    @property
    def canChangeDirectionEnRoute(self):
        return bool()

    @property
    def nextSystemID(self):
        return int()

    @property
    def finalDestinationID(self):
        return int()

    @property
    def hasMonsters(self):
        return bool()

    @property
    def hasArmedShips(self):
        return bool()

    @property
    def fuel(self):
        return float()

    @property
    def aggressive(self):
        return bool()

    @property
    def speed(self):
        return float()

    @property
    def maxFuel(self):
        return float()

    @property
    def empty(self):
        return bool()


class planet(universeObject, popCenter, resourceCenter):
    @property
    def originalType(self):
        return planetType()

    @property
    def distanceFromOriginalType(self):
        return int()

    @property
    def clockwiseNextPlanetType(self):
        return planetType()

    @property
    def type(self):
        return planetType()

    @property
    def nextLargerPlanetSize(self):
        return planetSize()

    @property
    def buildingIDs(self):
        return IntSet()

    @property
    def OrbitalPeriod(self):
        pass

    @property
    def counterClockwiseNextPlanetType(self):
        return planetType()

    @property
    def RotationalPeriod(self):
        pass

    @property
    def InitialOrbitalPosition(self):
        pass

    @property
    def nextSmallerPlanetSize(self):
        return planetSize()

    @property
    def size(self):
        return planetSize()

    def environmentForSpecies(self, string):
        """
        C++ signature:
            enum PlanetEnvironment environmentForSpecies(class Planet {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype planetEnvironment
        """
        return planetEnvironment()

    def OrbitalPositionOnTurn(self, number):
        """
        C++ signature:
            class Radian OrbitalPositionOnTurn(class Planet {lvalue},int)
        
        :param number:
        :type number: int
        :rtype object
        """
        return object()

    def nextBetterPlanetTypeForSpecies(self, string):
        """
        C++ signature:
            enum PlanetType nextBetterPlanetTypeForSpecies(class Planet {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param string:
        :type string: str
        :rtype planetType
        """
        return planetType()


class ship(universeObject):
    @property
    def speciesName(self):
        return str()

    @property
    def orderedScrapped(self):
        return bool()

    @property
    def isArmed(self):
        return bool()

    @property
    def designID(self):
        return int()

    @property
    def canColonize(self):
        return bool()

    @property
    def partMeters(self):
        return ShipPartMeterMap()

    @property
    def canInvade(self):
        return bool()

    @property
    def producedByEmpireID(self):
        return int()

    @property
    def isMonster(self):
        return bool()

    @property
    def design(self):
        return shipDesign()

    @property
    def orderedInvadePlanet(self):
        return int()

    @property
    def fleetID(self):
        return int()

    @property
    def speed(self):
        return float()

    @property
    def orderedColonizePlanet(self):
        return int()

    def currentPartMeterValue(self, meter_type, string):
        """
        C++ signature:
            float currentPartMeterValue(class Ship {lvalue},enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param meter_type:
        :type meter_type: meterType
        :param string:
        :type string: str
        :rtype float
        """
        return float()

    def initialPartMeterValue(self, meter_type, string):
        """
        C++ signature:
            float initialPartMeterValue(class Ship {lvalue},enum MeterType,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
        
        :param meter_type:
        :type meter_type: meterType
        :param string:
        :type string: str
        :rtype float
        """
        return float()


class system(universeObject):
    @property
    def fleetIDs(self):
        return IntSet()

    @property
    def shipIDs(self):
        return IntSet()

    @property
    def starlanesWormholes(self):
        return IntBoolMap()

    @property
    def fieldIDs(self):
        return IntSet()

    @property
    def numWormholes(self):
        return int()

    @property
    def buildingIDs(self):
        return IntSet()

    @property
    def starType(self):
        return starType()

    @property
    def lastTurnBattleHere(self):
        return int()

    @property
    def planetIDs(self):
        return IntSet()

    @property
    def numStarlanes(self):
        return int()

    def HasStarlaneToSystemID(self, number):
        """
        C++ signature:
            bool HasStarlaneToSystemID(class System {lvalue},int)
        
        :param number:
        :type number: int
        :rtype bool
        """
        return bool()

    def HasWormholeToSystemID(self, number):
        """
        Currently unused.
        
        C++ signature:
            bool HasWormholeToSystemID(class System {lvalue},int)
        
        :param number:
        :type number: int
        :rtype bool
        """
        return bool()


class Enum(int):
    """Enum stub for docs, not really present in fo"""
    pass


class aggression(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    aggressive = None  # aggression(4, "aggressive")
    beginner = None  # aggression(0, "beginner")
    cautious = None  # aggression(2, "cautious")
    invalid = None  # aggression(-1, "invalid")
    maniacal = None  # aggression(5, "maniacal")
    turtle = None  # aggression(1, "turtle")
    typical = None  # aggression(3, "typical")

aggression.invalid = aggression(-1, "invalid")
aggression.beginner = aggression(0, "beginner")
aggression.turtle = aggression(1, "turtle")
aggression.cautious = aggression(2, "cautious")
aggression.typical = aggression(3, "typical")
aggression.aggressive = aggression(4, "aggressive")
aggression.maniacal = aggression(5, "maniacal")


class buildType(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    building = None  # buildType(1, "building")
    ship = None  # buildType(2, "ship")

buildType.building = buildType(1, "building")
buildType.ship = buildType(2, "ship")


class captureResult(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    capture = None  # captureResult(0, "capture")
    destroy = None  # captureResult(1, "destroy")
    retain = None  # captureResult(2, "retain")

captureResult.capture = captureResult(0, "capture")
captureResult.destroy = captureResult(1, "destroy")
captureResult.retain = captureResult(2, "retain")


class diplomaticMessageType(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    acceptProposal = None  # diplomaticMessageType(2, "acceptProposal")
    cancelProposal = None  # diplomaticMessageType(3, "cancelProposal")
    noMessage = None  # diplomaticMessageType(-1, "noMessage")
    peaceProposal = None  # diplomaticMessageType(1, "peaceProposal")
    warDeclaration = None  # diplomaticMessageType(0, "warDeclaration")

diplomaticMessageType.noMessage = diplomaticMessageType(-1, "noMessage")
diplomaticMessageType.warDeclaration = diplomaticMessageType(0, "warDeclaration")
diplomaticMessageType.peaceProposal = diplomaticMessageType(1, "peaceProposal")
diplomaticMessageType.acceptProposal = diplomaticMessageType(2, "acceptProposal")
diplomaticMessageType.cancelProposal = diplomaticMessageType(3, "cancelProposal")


class diplomaticStatus(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    peace = None  # diplomaticStatus(1, "peace")
    war = None  # diplomaticStatus(0, "war")

diplomaticStatus.war = diplomaticStatus(0, "war")
diplomaticStatus.peace = diplomaticStatus(1, "peace")


class galaxySetupOption(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    high = None  # galaxySetupOption(3, "high")
    invalid = None  # galaxySetupOption(-1, "invalid")
    low = None  # galaxySetupOption(1, "low")
    medium = None  # galaxySetupOption(2, "medium")
    none = None  # galaxySetupOption(0, "none")

galaxySetupOption.invalid = galaxySetupOption(-1, "invalid")
galaxySetupOption.none = galaxySetupOption(0, "none")
galaxySetupOption.low = galaxySetupOption(1, "low")
galaxySetupOption.medium = galaxySetupOption(2, "medium")
galaxySetupOption.high = galaxySetupOption(3, "high")


class galaxyShape(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    cluster = None  # galaxyShape(3, "cluster")
    elliptical = None  # galaxyShape(4, "elliptical")
    invalid = None  # galaxyShape(-1, "invalid")
    irregular1 = None  # galaxyShape(5, "irregular1")
    irregular2 = None  # galaxyShape(6, "irregular2")
    random = None  # galaxyShape(8, "random")
    ring = None  # galaxyShape(7, "ring")
    spiral2 = None  # galaxyShape(0, "spiral2")
    spiral3 = None  # galaxyShape(1, "spiral3")
    spiral4 = None  # galaxyShape(2, "spiral4")

galaxyShape.invalid = galaxyShape(-1, "invalid")
galaxyShape.spiral2 = galaxyShape(0, "spiral2")
galaxyShape.spiral3 = galaxyShape(1, "spiral3")
galaxyShape.spiral4 = galaxyShape(2, "spiral4")
galaxyShape.cluster = galaxyShape(3, "cluster")
galaxyShape.elliptical = galaxyShape(4, "elliptical")
galaxyShape.irregular1 = galaxyShape(5, "irregular1")
galaxyShape.irregular2 = galaxyShape(6, "irregular2")
galaxyShape.ring = galaxyShape(7, "ring")
galaxyShape.random = galaxyShape(8, "random")


class meterType(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    capacity = None  # meterType(30, "capacity")
    construction = None  # meterType(16, "construction")
    damage = None  # meterType(29, "damage")
    defense = None  # meterType(21, "defense")
    detection = None  # meterType(27, "detection")
    fuel = None  # meterType(18, "fuel")
    industry = None  # meterType(13, "industry")
    maxDefense = None  # meterType(9, "maxDefense")
    maxFuel = None  # meterType(6, "maxFuel")
    maxShield = None  # meterType(7, "maxShield")
    maxStructure = None  # meterType(8, "maxStructure")
    maxSupply = None  # meterType(11, "maxSupply")
    maxTroops = None  # meterType(10, "maxTroops")
    population = None  # meterType(12, "population")
    rebels = None  # meterType(24, "rebels")
    research = None  # meterType(14, "research")
    shield = None  # meterType(19, "shield")
    size = None  # meterType(25, "size")
    starlaneSpeed = None  # meterType(28, "starlaneSpeed")
    stealth = None  # meterType(26, "stealth")
    structure = None  # meterType(20, "structure")
    supply = None  # meterType(23, "supply")
    targetConstruction = None  # meterType(4, "targetConstruction")
    targetIndustry = None  # meterType(1, "targetIndustry")
    targetPopulation = None  # meterType(0, "targetPopulation")
    targetResearch = None  # meterType(2, "targetResearch")
    targetTrade = None  # meterType(3, "targetTrade")
    trade = None  # meterType(15, "trade")
    troops = None  # meterType(22, "troops")

meterType.targetPopulation = meterType(0, "targetPopulation")
meterType.targetIndustry = meterType(1, "targetIndustry")
meterType.targetResearch = meterType(2, "targetResearch")
meterType.targetTrade = meterType(3, "targetTrade")
meterType.targetConstruction = meterType(4, "targetConstruction")
meterType.maxFuel = meterType(6, "maxFuel")
meterType.maxShield = meterType(7, "maxShield")
meterType.maxStructure = meterType(8, "maxStructure")
meterType.maxDefense = meterType(9, "maxDefense")
meterType.maxTroops = meterType(10, "maxTroops")
meterType.maxSupply = meterType(11, "maxSupply")
meterType.population = meterType(12, "population")
meterType.industry = meterType(13, "industry")
meterType.research = meterType(14, "research")
meterType.trade = meterType(15, "trade")
meterType.construction = meterType(16, "construction")
meterType.fuel = meterType(18, "fuel")
meterType.shield = meterType(19, "shield")
meterType.structure = meterType(20, "structure")
meterType.defense = meterType(21, "defense")
meterType.troops = meterType(22, "troops")
meterType.supply = meterType(23, "supply")
meterType.rebels = meterType(24, "rebels")
meterType.size = meterType(25, "size")
meterType.stealth = meterType(26, "stealth")
meterType.detection = meterType(27, "detection")
meterType.starlaneSpeed = meterType(28, "starlaneSpeed")
meterType.damage = meterType(29, "damage")
meterType.capacity = meterType(30, "capacity")


class planetEnvironment(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    adequate = None  # planetEnvironment(3, "adequate")
    good = None  # planetEnvironment(4, "good")
    hostile = None  # planetEnvironment(1, "hostile")
    poor = None  # planetEnvironment(2, "poor")
    uninhabitable = None  # planetEnvironment(0, "uninhabitable")

planetEnvironment.uninhabitable = planetEnvironment(0, "uninhabitable")
planetEnvironment.hostile = planetEnvironment(1, "hostile")
planetEnvironment.poor = planetEnvironment(2, "poor")
planetEnvironment.adequate = planetEnvironment(3, "adequate")
planetEnvironment.good = planetEnvironment(4, "good")


class planetSize(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    asteroids = None  # planetSize(6, "asteroids")
    gasGiant = None  # planetSize(7, "gasGiant")
    huge = None  # planetSize(5, "huge")
    large = None  # planetSize(4, "large")
    medium = None  # planetSize(3, "medium")
    noWorld = None  # planetSize(0, "noWorld")
    small = None  # planetSize(2, "small")
    tiny = None  # planetSize(1, "tiny")
    unknown = None  # planetSize(-1, "unknown")

planetSize.unknown = planetSize(-1, "unknown")
planetSize.noWorld = planetSize(0, "noWorld")
planetSize.tiny = planetSize(1, "tiny")
planetSize.small = planetSize(2, "small")
planetSize.medium = planetSize(3, "medium")
planetSize.large = planetSize(4, "large")
planetSize.huge = planetSize(5, "huge")
planetSize.asteroids = planetSize(6, "asteroids")
planetSize.gasGiant = planetSize(7, "gasGiant")


class planetType(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    asteroids = None  # planetType(9, "asteroids")
    barren = None  # planetType(4, "barren")
    desert = None  # planetType(6, "desert")
    gasGiant = None  # planetType(10, "gasGiant")
    inferno = None  # planetType(2, "inferno")
    ocean = None  # planetType(8, "ocean")
    radiated = None  # planetType(3, "radiated")
    swamp = None  # planetType(0, "swamp")
    terran = None  # planetType(7, "terran")
    toxic = None  # planetType(1, "toxic")
    tundra = None  # planetType(5, "tundra")
    unknown = None  # planetType(-1, "unknown")

planetType.unknown = planetType(-1, "unknown")
planetType.swamp = planetType(0, "swamp")
planetType.toxic = planetType(1, "toxic")
planetType.inferno = planetType(2, "inferno")
planetType.radiated = planetType(3, "radiated")
planetType.barren = planetType(4, "barren")
planetType.tundra = planetType(5, "tundra")
planetType.desert = planetType(6, "desert")
planetType.terran = planetType(7, "terran")
planetType.ocean = planetType(8, "ocean")
planetType.asteroids = planetType(9, "asteroids")
planetType.gasGiant = planetType(10, "gasGiant")


class resourceType(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    industry = None  # resourceType(0, "industry")
    research = None  # resourceType(2, "research")
    trade = None  # resourceType(1, "trade")

resourceType.industry = resourceType(0, "industry")
resourceType.trade = resourceType(1, "trade")
resourceType.research = resourceType(2, "research")


class shipPartClass(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    armour = None  # shipPartClass(5, "armour")
    bombard = None  # shipPartClass(13, "bombard")
    colony = None  # shipPartClass(10, "colony")
    detection = None  # shipPartClass(7, "detection")
    fighters = None  # shipPartClass(2, "fighters")
    fuel = None  # shipPartClass(9, "fuel")
    general = None  # shipPartClass(12, "general")
    industry = None  # shipPartClass(14, "industry")
    missiles = None  # shipPartClass(1, "missiles")
    pointDefense = None  # shipPartClass(3, "pointDefense")
    productionLocation = None  # shipPartClass(17, "productionLocation")
    research = None  # shipPartClass(15, "research")
    shields = None  # shipPartClass(4, "shields")
    shortRange = None  # shipPartClass(0, "shortRange")
    starlaneSpeed = None  # shipPartClass(11, "starlaneSpeed")
    stealth = None  # shipPartClass(8, "stealth")
    trade = None  # shipPartClass(16, "trade")
    troops = None  # shipPartClass(6, "troops")

shipPartClass.shortRange = shipPartClass(0, "shortRange")
shipPartClass.missiles = shipPartClass(1, "missiles")
shipPartClass.fighters = shipPartClass(2, "fighters")
shipPartClass.pointDefense = shipPartClass(3, "pointDefense")
shipPartClass.shields = shipPartClass(4, "shields")
shipPartClass.armour = shipPartClass(5, "armour")
shipPartClass.troops = shipPartClass(6, "troops")
shipPartClass.detection = shipPartClass(7, "detection")
shipPartClass.stealth = shipPartClass(8, "stealth")
shipPartClass.fuel = shipPartClass(9, "fuel")
shipPartClass.colony = shipPartClass(10, "colony")
shipPartClass.starlaneSpeed = shipPartClass(11, "starlaneSpeed")
shipPartClass.general = shipPartClass(12, "general")
shipPartClass.bombard = shipPartClass(13, "bombard")
shipPartClass.industry = shipPartClass(14, "industry")
shipPartClass.research = shipPartClass(15, "research")
shipPartClass.trade = shipPartClass(16, "trade")
shipPartClass.productionLocation = shipPartClass(17, "productionLocation")


class shipSlotType(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    core = None  # shipSlotType(2, "core")
    external = None  # shipSlotType(0, "external")
    internal = None  # shipSlotType(1, "internal")

shipSlotType.external = shipSlotType(0, "external")
shipSlotType.internal = shipSlotType(1, "internal")
shipSlotType.core = shipSlotType(2, "core")


class starType(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    blackHole = None  # starType(6, "blackHole")
    blue = None  # starType(0, "blue")
    neutron = None  # starType(5, "neutron")
    noStar = None  # starType(7, "noStar")
    orange = None  # starType(3, "orange")
    red = None  # starType(4, "red")
    unknown = None  # starType(-1, "unknown")
    white = None  # starType(1, "white")
    yellow = None  # starType(2, "yellow")

starType.unknown = starType(-1, "unknown")
starType.blue = starType(0, "blue")
starType.white = starType(1, "white")
starType.yellow = starType(2, "yellow")
starType.orange = starType(3, "orange")
starType.red = starType(4, "red")
starType.neutron = starType(5, "neutron")
starType.blackHole = starType(6, "blackHole")
starType.noStar = starType(7, "noStar")


class techStatus(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    complete = None  # techStatus(2, "complete")
    researchable = None  # techStatus(1, "researchable")
    unresearchable = None  # techStatus(0, "unresearchable")

techStatus.unresearchable = techStatus(0, "unresearchable")
techStatus.researchable = techStatus(1, "researchable")
techStatus.complete = techStatus(2, "complete")


class techType(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    application = None  # techType(1, "application")
    refinement = None  # techType(2, "refinement")
    theory = None  # techType(0, "theory")

techType.theory = techType(0, "theory")
techType.application = techType(1, "application")
techType.refinement = techType(2, "refinement")


class unlockableItemType(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    building = None  # unlockableItemType(0, "building")
    invalid = None  # unlockableItemType(-1, "invalid")
    shipDesign = None  # unlockableItemType(3, "shipDesign")
    shipHull = None  # unlockableItemType(2, "shipHull")
    shipPart = None  # unlockableItemType(1, "shipPart")
    tech = None  # unlockableItemType(4, "tech")

unlockableItemType.invalid = unlockableItemType(-1, "invalid")
unlockableItemType.building = unlockableItemType(0, "building")
unlockableItemType.shipPart = unlockableItemType(1, "shipPart")
unlockableItemType.shipHull = unlockableItemType(2, "shipHull")
unlockableItemType.shipDesign = unlockableItemType(3, "shipDesign")
unlockableItemType.tech = unlockableItemType(4, "tech")


class visibility(Enum):
    def __init__(self, numerator, name):
        self.name = name
        self.numerator = numerator

    basic = None  # visibility(1, "basic")
    full = None  # visibility(3, "full")
    invalid = None  # visibility(-1, "invalid")
    none = None  # visibility(0, "none")
    partial = None  # visibility(2, "partial")

visibility.invalid = visibility(-1, "invalid")
visibility.none = visibility(0, "none")
visibility.basic = visibility(1, "basic")
visibility.partial = visibility(2, "partial")
visibility.full = visibility(3, "full")


def allEmpireIDs():
    """
    C++ signature:
        class std::vector<int,class std::allocator<int> > allEmpireIDs()
    :rtype IntVec
    """
    return IntVec()


def allPlayerIDs():
    """
    C++ signature:
        class std::vector<int,class std::allocator<int> > allPlayerIDs()
    :rtype IntVec
    """
    return IntVec()


def currentTurn():
    """
    C++ signature:
        int currentTurn()
    :rtype int
    """
    return int()


def doneTurn():
    """
    C++ signature:
        void doneTurn()
    :rtype None
    """
    return None


def empireID():
    """
    C++ signature:
        int empireID()
    :rtype int
    """
    return int()


def empirePlayerID(number):
    """
    C++ signature:
        int empirePlayerID(int)
    
    :param number:
    :type number: int
    :rtype int
    """
    return int()


def getAIConfigStr():
    """
    C++ signature:
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getAIConfigStr()
    :rtype str
    """
    return str()


def getAIDir():
    """
    C++ signature:
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getAIDir()
    :rtype str
    """
    return str()


def getBuildingType(string):
    """
    C++ signature:
        class BuildingType const * getBuildingType(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype buildingType
    """
    return buildingType()


def getEmpire():
    """
    C++ signatures:
        class Empire const * getEmpire()
        class Empire const * getEmpire(int)
    :rtype empire
    """
    return empire()


def getFieldType(string):
    """
    C++ signature:
        class FieldType const * getFieldType(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype fieldType
    """
    return fieldType()


def getGalaxySetupData():
    """
    C++ signature:
        struct GalaxySetupData getGalaxySetupData()
    :rtype galaxySetupData
    """
    return galaxySetupData()


def getHullType(string):
    """
    C++ signature:
        class HullType const * getHullType(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype hullType
    """
    return hullType()


def getPartType(string):
    """
    C++ signature:
        class PartType const * getPartType(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype partType
    """
    return partType()


def getSaveStateString():
    """
    C++ signature:
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getSaveStateString()
    :rtype str
    """
    return str()


def getShipDesign(number):
    """
    C++ signature:
        class ShipDesign const * getShipDesign(int)
    
    :param number:
    :type number: int
    :rtype shipDesign
    """
    return shipDesign()


def getSpecial(string):
    """
    C++ signature:
        class Special const * getSpecial(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype special
    """
    return special()


def getSpecies(string):
    """
    C++ signature:
        class Species const * getSpecies(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype species
    """
    return species()


def getTech(string):
    """
    C++ signature:
        class Tech const * getTech(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype tech
    """
    return tech()


def getTechCategories(obj):
    """
    C++ signature:
        class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > getTechCategories(class TechManager {lvalue})
    
    :param obj:
    :type obj: object
    :rtype StringVec
    """
    return StringVec()


def getUniverse():
    """
    C++ signature:
        class Universe getUniverse()
    :rtype universe
    """
    return universe()


def issueAggressionOrder(number, boolean):
    """
    C++ signature:
        int issueAggressionOrder(int,bool)
    
    :param number:
    :type number: int
    :param boolean:
    :type boolean: bool
    :rtype int
    """
    return int()


def issueBombardOrder(number1, number2):
    """
    C++ signature:
        int issueBombardOrder(int,int)
    
    :param number1:
    :type number1: int
    :param number2:
    :type number2: int
    :rtype int
    """
    return int()


def issueChangeFocusOrder(number, string):
    """
    C++ signature:
        int issueChangeFocusOrder(int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param number:
    :type number: int
    :param string:
    :type string: str
    :rtype int
    """
    return int()


def issueChangeProductionQuantityOrder(number1, number2, number3):
    """
    C++ signature:
        int issueChangeProductionQuantityOrder(int,int,int)
    
    :param number1:
    :type number1: int
    :param number2:
    :type number2: int
    :param number3:
    :type number3: int
    :rtype int
    """
    return int()


def issueColonizeOrder(number1, number2):
    """
    C++ signature:
        int issueColonizeOrder(int,int)
    
    :param number1:
    :type number1: int
    :param number2:
    :type number2: int
    :rtype int
    """
    return int()


def issueCreateShipDesignOrder(string1, string2, string3, item_list, string4, string5, boolean):
    """
    C++ signature:
        int issueCreateShipDesignOrder(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class boost::python::list,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,bool)
    
    :param string1:
    :type string1: str
    :param string2:
    :type string2: str
    :param string3:
    :type string3: str
    :param item_list:
    :type item_list: list
    :param string4:
    :type string4: str
    :param string5:
    :type string5: str
    :param boolean:
    :type boolean: bool
    :rtype int
    """
    return int()


def issueDequeueProductionOrder(number):
    """
    C++ signature:
        int issueDequeueProductionOrder(int)
    
    :param number:
    :type number: int
    :rtype int
    """
    return int()


def issueDequeueTechOrder(string):
    """
    C++ signature:
        int issueDequeueTechOrder(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype int
    """
    return int()


def issueEnqueueBuildingProductionOrder(string, number):
    """
    C++ signature:
        int issueEnqueueBuildingProductionOrder(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)
    
    :param string:
    :type string: str
    :param number:
    :type number: int
    :rtype int
    """
    return int()


def issueEnqueueShipProductionOrder(number1, number2):
    """
    C++ signature:
        int issueEnqueueShipProductionOrder(int,int)
    
    :param number1:
    :type number1: int
    :param number2:
    :type number2: int
    :rtype int
    """
    return int()


def issueEnqueueTechOrder(string, number):
    """
    C++ signature:
        int issueEnqueueTechOrder(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)
    
    :param string:
    :type string: str
    :param number:
    :type number: int
    :rtype int
    """
    return int()


def issueFleetMoveOrder(number1, number2):
    """
    C++ signature:
        int issueFleetMoveOrder(int,int)
    
    :param number1:
    :type number1: int
    :param number2:
    :type number2: int
    :rtype int
    """
    return int()


def issueFleetTransferOrder(number1, number2):
    """
    C++ signature:
        int issueFleetTransferOrder(int,int)
    
    :param number1:
    :type number1: int
    :param number2:
    :type number2: int
    :rtype int
    """
    return int()


def issueGiveObjectToEmpireOrder(number1, number2):
    """
    C++ signature:
        int issueGiveObjectToEmpireOrder(int,int)
    
    :param number1:
    :type number1: int
    :param number2:
    :type number2: int
    :rtype int
    """
    return int()


def issueInvadeOrder(number1, number2):
    """
    C++ signature:
        int issueInvadeOrder(int,int)
    
    :param number1:
    :type number1: int
    :param number2:
    :type number2: int
    :rtype int
    """
    return int()


def issueNewFleetOrder(string, number):
    """
    C++ signature:
        int issueNewFleetOrder(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)
    
    :param string:
    :type string: str
    :param number:
    :type number: int
    :rtype int
    """
    return int()


def issueRenameOrder(number, string):
    """
    C++ signature:
        int issueRenameOrder(int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param number:
    :type number: int
    :param string:
    :type string: str
    :rtype int
    """
    return int()


def issueRequeueProductionOrder(number1, number2):
    """
    C++ signature:
        int issueRequeueProductionOrder(int,int)
    
    :param number1:
    :type number1: int
    :param number2:
    :type number2: int
    :rtype int
    """
    return int()


def issueScrapOrder(number):
    """
    C++ signature:
        int issueScrapOrder(int)
    
    :param number:
    :type number: int
    :rtype int
    """
    return int()


def playerEmpireID(number):
    """
    C++ signature:
        int playerEmpireID(int)
    
    :param number:
    :type number: int
    :rtype int
    """
    return int()


def playerID():
    """
    C++ signature:
        int playerID()
    :rtype int
    """
    return int()


def playerIsAI(number):
    """
    C++ signature:
        bool playerIsAI(int)
    
    :param number:
    :type number: int
    :rtype bool
    """
    return bool()


def playerIsHost(number):
    """
    C++ signature:
        bool playerIsHost(int)
    
    :param number:
    :type number: int
    :rtype bool
    """
    return bool()


def playerName():
    """
    C++ signatures:
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > playerName()
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > playerName(int)
    :rtype str
    """
    return str()


def sendChatMessage(number, string):
    """
    C++ signature:
        void sendChatMessage(int,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param number:
    :type number: int
    :param string:
    :type string: str
    :rtype None
    """
    return None


def sendDiplomaticMessage(diplomatic_message):
    """
    C++ signature:
        void sendDiplomaticMessage(class DiplomaticMessage)
    
    :param diplomatic_message:
    :type diplomatic_message: diplomaticMessage
    :rtype None
    """
    return None


def setSaveStateString(string):
    """
    C++ signature:
        void setSaveStateString(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype None
    """
    return None


def techs():
    """
    C++ signature:
        class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > techs()
    :rtype StringVec
    """
    return StringVec()


def techsInCategory(string):
    """
    C++ signature:
        class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > > techsInCategory(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype StringVec
    """
    return StringVec()


def updateMeterEstimates(boolean):
    """
    C++ signature:
        void updateMeterEstimates(bool)
    
    :param boolean:
    :type boolean: bool
    :rtype None
    """
    return None


def updateProductionQueue():
    """
    C++ signature:
        void updateProductionQueue()
    :rtype None
    """
    return None


def updateResearchQueue():
    """
    C++ signature:
        void updateResearchQueue()
    :rtype None
    """
    return None


def updateResourcePools():
    """
    C++ signature:
        void updateResourcePools()
    :rtype None
    """
    return None


def userString(string):
    """
    C++ signature:
        class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > userString(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)
    
    :param string:
    :type string: str
    :rtype str
    """
    return str()


def validShipDesign(string, string_list):
    """
    C++ signatures:
        bool validShipDesign(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::vector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::allocator<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > >)
        bool validShipDesign(class ShipDesign)
    
    :param string:
    :type string: str
    :param string_list:
    :type string_list: StringVec
    :rtype bool
    """
    return bool()