# CONFIDENTIAL. (C) 2017 OpenEye Scientific Software Inc.
# All rights reserved.
# 
# ALL SOFTWARE BELOW IS PROPRIETARY AND CONFIDENTIAL TO OPENEYE
# SCIENTIFIC SOFTWARE INC., AND IS SUBJECT TO THE FULL PROTECTION OF
# COPYRIGHT AND TRADESECRET LAW.
# Copying or modifying this software is strictly prohibited and illegal.
# Using this software without a valid license from OpenEye is strictly
# prohibited and illegal.  De-obfuscating, de-minimizing, or any other
# attempt to reverse engineer or discover the workings of this software,
# is strictly prohibited. Even if software is exposed or visible, it is
# still proprietary and confidential and the above prohibitions apply.
# This software is NOT "Sample Code". For purposes of customization or
# interoperation with other software you must use Sample Code
# specifically labeled as such.
# Please contact OpenEye at eyesopen.com/legal if you have any questions
# about this warning.


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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")


def swig_import_helper():
    from os.path import dirname
    import importlib.util

    spec = importlib.machinery.PathFinder().find_spec("_oechem", [dirname(__file__)])

    if spec is None:
        # OpenEye Import Statements
        spec = importlib.machinery.PathFinder().find_spec("libs",[dirname(__file__)])
    libs = importlib.util.module_from_spec(spec)

    import sys
    sys.modules[spec.name] = libs
    spec.loader.exec_module(libs)

    assert not sys.platform.startswith('win')

    _oequacpac = libs.OEGetModule('_oequacpac2121')
    return _oequacpac

_oequacpac = swig_import_helper()
del swig_import_helper

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


import weakref


def SwigNumber_Check(o: "PyObject *") -> "double":
    return _oequacpac.SwigNumber_Check(o)

def SwigNumber_AsDouble(o: "PyObject *") -> "double":
    return _oequacpac.SwigNumber_AsDouble(o)

def __no_op(*args) -> "void":
    return _oequacpac.__no_op(*args)
import openeye.oechem as oechem
class OEMolFunctionBase(object):
    r"""Proxy of C++ OESystem::OEUnaryFunction< OEChem::OEMolBase,bool,true,false > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEMolFunctionBase

    def __call__(self, arg2: "OEMolBase") -> "bool":
        r"""__call__(OEMolFunctionBase self, OEMolBase arg2) -> bool"""
        return _oequacpac.OEMolFunctionBase___call__(self, arg2)

    def CreateCopy(self) -> "OESystem::OEUnaryFunction< OEChem::OEMolBase,bool,true,false >::base_type *":
        r"""CreateCopy(OEMolFunctionBase self) -> OEMolFunctionBase"""
        return _oequacpac.OEMolFunctionBase_CreateCopy(self)

# Register OEMolFunctionBase in _oequacpac:
_oequacpac.OEMolFunctionBase_swigregister(OEMolFunctionBase)

OEMethodType_AM1 = _oequacpac.OEMethodType_AM1

OEMethodType_PM3 = _oequacpac.OEMethodType_PM3

OEBCCType_AM1 = _oequacpac.OEBCCType_AM1

OEBCCType_PM3 = _oequacpac.OEBCCType_PM3

OECharges_NoOp = _oequacpac.OECharges_NoOp

OECharges_None = _oequacpac.OECharges_None

OECharges_Formal = _oequacpac.OECharges_Formal

OECharges_Initial = _oequacpac.OECharges_Initial

OECharges_Gasteiger = _oequacpac.OECharges_Gasteiger

OECharges_MMFF94 = _oequacpac.OECharges_MMFF94

OECharges_AM1BCCNoSym = _oequacpac.OECharges_AM1BCCNoSym

OECharges_AM1BCCNoSymSPt = _oequacpac.OECharges_AM1BCCNoSymSPt

OECharges_AM1BCCSym = _oequacpac.OECharges_AM1BCCSym

OECharges_AM1BCCSymSPt = _oequacpac.OECharges_AM1BCCSymSPt


OECharges_AM1BCC = OECharges_AM1BCCNoSym


OECharges_AM1BCCSPt = OECharges_AM1BCCNoSymSPt

OECharges_OPLS = _oequacpac.OECharges_OPLS

OECharges_AM1 = _oequacpac.OECharges_AM1

OECharges_AM1SPt = _oequacpac.OECharges_AM1SPt

OECharges_AmberFF94 = _oequacpac.OECharges_AmberFF94


OECharges_AmberFF99 = OECharges_AmberFF94


OECharges_AmberFF99SB = OECharges_AmberFF94


OECharges_AmberFF99bsc0 = OECharges_AmberFF94

OECharges_FmlToPrtl = _oequacpac.OECharges_FmlToPrtl

OECharges_Combine = _oequacpac.OECharges_Combine

OECharges_ELF = _oequacpac.OECharges_ELF

OECharges_SpreadMetal = _oequacpac.OECharges_SpreadMetal

OECharges_DUCharges = _oequacpac.OECharges_DUCharges

OECharges_CmplxCharges = _oequacpac.OECharges_CmplxCharges

OECharges_Max = _oequacpac.OECharges_Max


OECharges_Default = OECharges_MMFF94

OEHybridizationLevel_Original = _oequacpac.OEHybridizationLevel_Original

OEHybridizationLevel_DoubleBondNbr = _oequacpac.OEHybridizationLevel_DoubleBondNbr

OEHybridizationLevel_EnolEnamine = _oequacpac.OEHybridizationLevel_EnolEnamine


OEHybridizationLevel_Default = OEHybridizationLevel_EnolEnamine

OERacemicType_None = _oequacpac.OERacemicType_None

OERacemicType_LocalSampled = _oequacpac.OERacemicType_LocalSampled

OERacemicType_EverSampled = _oequacpac.OERacemicType_EverSampled

class OEFComponentIter(object):
    r"""Proxy of C++ OESystem::OEIter< OEOpt::OEFComponent > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEFComponentIter self) -> OEFComponentIter
        __init__(OEFComponentIter self, OEFComponentIter rhs) -> OEFComponentIter
        __init__(OEFComponentIter self, OESystem::OEIterBase< OEOpt::OEFComponent > * rhs) -> OEFComponentIter
        __init__(OEFComponentIter self, OESystem::OEIterBase< OESystem::OEIter< OEOpt::OEFComponent >::NonConstA > * rhs) -> OEFComponentIter
        """
        _oequacpac.OEFComponentIter_swiginit(self, _oequacpac.new_OEFComponentIter(*args))
    __swig_destroy__ = _oequacpac.delete_OEFComponentIter

    def Copy(self) -> "OESystem::OEIterBase< OEOpt::OEFComponent > *":
        r"""Copy(OEFComponentIter self) -> OESystem::OEIterBase< OEOpt::OEFComponent > *"""
        return _oequacpac.OEFComponentIter_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OEFComponentIter self, OESystem::OEIterBase< OEOpt::OEFComponent > * ib)
        Push(OEFComponentIter self, OEFComponentIter iter)
        """
        return _oequacpac.OEFComponentIter_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEOpt::OEFComponent,OEOpt::OEFComponent > const &") -> "void":
        r"""Sort(OEFComponentIter self, OESystem::OEBinaryPredicate< OEOpt::OEFComponent,OEOpt::OEFComponent > const & sort_criterion)"""
        return _oequacpac.OEFComponentIter_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEOpt::OEFComponent > &":
        r"""ToFirst(OEFComponentIter self) -> OEFComponentIter"""
        return _oequacpac.OEFComponentIter_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEOpt::OEFComponent > &":
        r"""ToLast(OEFComponentIter self) -> OEFComponentIter"""
        return _oequacpac.OEFComponentIter_ToLast(self)

    def __ref__(self) -> "OEOpt::OEFComponent &":
        r"""__ref__(OEFComponentIter self) -> OEFComponent"""
        return _oequacpac.OEFComponentIter___ref__(self)

    def IsValid(self):
      return _oequacpac.OEFComponentIter___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OEFComponentIter self) -> PyObject *"""
        return _oequacpac.OEFComponentIter_next(self)

    def Target(self) -> "OEOpt::OEFComponent &":
        r"""Target(OEFComponentIter self) -> OEFComponent"""
        return _oequacpac.OEFComponentIter_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEOpt::OEFComponent > &":
        r"""
        Next(OEFComponentIter self) -> OEFComponentIter
        Next(OEFComponentIter self, int i) -> OEFComponentIter
        """
        return _oequacpac.OEFComponentIter_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEOpt::OEFComponent > &":
        r"""
        Prev(OEFComponentIter self) -> OEFComponentIter
        Prev(OEFComponentIter self, int i) -> OEFComponentIter
        """
        return _oequacpac.OEFComponentIter_Prev(self, *args)

# Register OEFComponentIter in _oequacpac:
_oequacpac.OEFComponentIter_swigregister(OEFComponentIter)

class OEFComponent(object):
    r"""Proxy of C++ OEOpt::OEFComponent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_oequacpac.OEFComponent_name_get, _oequacpac.OEFComponent_name_set, doc=r"""name : std::string""")
    value = property(_oequacpac.OEFComponent_value_get, _oequacpac.OEFComponent_value_set, doc=r"""value : double""")

    def __init__(self, *args):
        r"""
        __init__(OEFComponent self) -> OEFComponent
        __init__(OEFComponent self, std::string const & n, double v) -> OEFComponent
        """
        _oequacpac.OEFComponent_swiginit(self, _oequacpac.new_OEFComponent(*args))
    __swig_destroy__ = _oequacpac.delete_OEFComponent

# Register OEFComponent in _oequacpac:
_oequacpac.OEFComponent_swigregister(OEFComponent)

class OEFunc0(object):
    r"""Proxy of C++ OEOpt::OEFunc0 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def NumVar(self) -> "unsigned int":
        r"""NumVar(OEFunc0 self) -> unsigned int"""
        return _oequacpac.OEFunc0_NumVar(self)

    def __call__(self, x: "double const *") -> "double":
        r"""__call__(OEFunc0 self, double const * x) -> double"""
        return _oequacpac.OEFunc0___call__(self, x)

    def GetFComponents(self, arg2: "double const *") -> "OESystem::OEIterBase< OEOpt::OEFComponent > *":
        r"""GetFComponents(OEFunc0 self, double const * arg2) -> OESystem::OEIterBase< OEOpt::OEFComponent > *"""
        return _oequacpac.OEFunc0_GetFComponents(self, arg2)
    __swig_destroy__ = _oequacpac.delete_OEFunc0

# Register OEFunc0 in _oequacpac:
_oequacpac.OEFunc0_swigregister(OEFunc0)

class OEFunc1(OEFunc0):
    r"""Proxy of C++ OEOpt::OEFunc1 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def NumVar(self) -> "unsigned int":
        r"""NumVar(OEFunc1 self) -> unsigned int"""
        return _oequacpac.OEFunc1_NumVar(self)

    def __call__(self, *args) -> "double":
        r"""
        __call__(OEFunc1 self, float const ** arg2) -> OEFloatVector
        __call__(OEFunc1 self, double const * x) -> double
        __call__(OEFunc1 self, double const * x, double * g) -> double
        """
        return _oequacpac.OEFunc1___call__(self, *args)

    def GetFComponents(self, arg2: "double const *") -> "OESystem::OEIterBase< OEOpt::OEFComponent > *":
        r"""GetFComponents(OEFunc1 self, double const * arg2) -> OESystem::OEIterBase< OEOpt::OEFComponent > *"""
        return _oequacpac.OEFunc1_GetFComponents(self, arg2)
    __swig_destroy__ = _oequacpac.delete_OEFunc1

# Register OEFunc1 in _oequacpac:
_oequacpac.OEFunc1_swigregister(OEFunc1)

class OEFunc2(OEFunc1):
    r"""Proxy of C++ OEOpt::OEFunc2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def __call__(self, *args) -> "bool":
        r"""
        __call__(OEFunc2 self, double const * x) -> double
        __call__(OEFunc2 self, double const * x, double * g) -> double
        __call__(OEFunc2 self, double const * x, double * h, double * g) -> bool
        """
        return _oequacpac.OEFunc2___call__(self, *args)
    __swig_destroy__ = _oequacpac.delete_OEFunc2

# Register OEFunc2 in _oequacpac:
_oequacpac.OEFunc2_swigregister(OEFunc2)


def GetSWIG_NewPointerObj(*args) -> "PyObject *":
    r"""
    GetSWIG_NewPointerObj(OEAtomBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEBondBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEMolBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEConfBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OETransBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OENbrs arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEAltLocation arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEAltGroup arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OESequenceAlignment arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OERole arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEResidue arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(std::string const & arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(std::string & arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OERotamer arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OETorsion arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEColor arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEColorStop arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEGroupBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEAtomBondSet arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OESubSearch arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEInteractionHintTypeBase arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEInteractionHint arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OESphere arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEReceptorProteinConstraint arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEReceptorConstraintFeature arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEHierResidue arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEHierFragment arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEHierChain arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEPlaceHydrogensMoverNote arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEAnnotation arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEFuzzy arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEFComponent arg, bool owned) -> PyObject
    GetSWIG_NewPointerObj(OEInteraction arg, bool owned) -> PyObject *
    """
    return _oequacpac.GetSWIG_NewPointerObj(*args)
class OEInteractionIter(object):
    r"""Proxy of C++ OESystem::OEIter< OEMolPotential::OEInteraction > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEInteractionIter self) -> OEInteractionIter
        __init__(OEInteractionIter self, OEInteractionIter rhs) -> OEInteractionIter
        __init__(OEInteractionIter self, OESystem::OEIterBase< OEMolPotential::OEInteraction > * rhs) -> OEInteractionIter
        __init__(OEInteractionIter self, OESystem::OEIterBase< OESystem::OEIter< OEMolPotential::OEInteraction >::NonConstA > * rhs) -> OEInteractionIter
        """
        _oequacpac.OEInteractionIter_swiginit(self, _oequacpac.new_OEInteractionIter(*args))
    __swig_destroy__ = _oequacpac.delete_OEInteractionIter

    def Copy(self) -> "OESystem::OEIterBase< OEMolPotential::OEInteraction > *":
        r"""Copy(OEInteractionIter self) -> OESystem::OEIterBase< OEMolPotential::OEInteraction > *"""
        return _oequacpac.OEInteractionIter_Copy(self)

    def Push(self, *args) -> "void":
        r"""
        Push(OEInteractionIter self, OESystem::OEIterBase< OEMolPotential::OEInteraction > * ib)
        Push(OEInteractionIter self, OEInteractionIter iter)
        """
        return _oequacpac.OEInteractionIter_Push(self, *args)

    def Sort(self, sort_criterion: "OESystem::OEBinaryPredicate< OEMolPotential::OEInteraction,OEMolPotential::OEInteraction > const &") -> "void":
        r"""Sort(OEInteractionIter self, OESystem::OEBinaryPredicate< OEMolPotential::OEInteraction,OEMolPotential::OEInteraction > const & sort_criterion)"""
        return _oequacpac.OEInteractionIter_Sort(self, sort_criterion)

    def ToFirst(self) -> "OESystem::OEIter< OEMolPotential::OEInteraction > &":
        r"""ToFirst(OEInteractionIter self) -> OEInteractionIter"""
        return _oequacpac.OEInteractionIter_ToFirst(self)

    def ToLast(self) -> "OESystem::OEIter< OEMolPotential::OEInteraction > &":
        r"""ToLast(OEInteractionIter self) -> OEInteractionIter"""
        return _oequacpac.OEInteractionIter_ToLast(self)

    def __ref__(self) -> "OEMolPotential::OEInteraction &":
        r"""__ref__(OEInteractionIter self) -> OEInteraction"""
        return _oequacpac.OEInteractionIter___ref__(self)

    def IsValid(self):
      return _oequacpac.OEInteractionIter___nonzero__(self)



    def __iter__(self):
        while self.IsValid():
            ret = self.Target()
            ret._itr = self
            yield ret
            self.Next()



    def next(self) -> "PyObject *":
        r"""next(OEInteractionIter self) -> PyObject *"""
        return _oequacpac.OEInteractionIter_next(self)

    def Target(self) -> "OEMolPotential::OEInteraction &":
        r"""Target(OEInteractionIter self) -> OEInteraction"""
        return _oequacpac.OEInteractionIter_Target(self)

    def Next(self, *args) -> "OESystem::OEIter< OEMolPotential::OEInteraction > &":
        r"""
        Next(OEInteractionIter self) -> OEInteractionIter
        Next(OEInteractionIter self, int i) -> OEInteractionIter
        """
        return _oequacpac.OEInteractionIter_Next(self, *args)

    def Prev(self, *args) -> "OESystem::OEIter< OEMolPotential::OEInteraction > &":
        r"""
        Prev(OEInteractionIter self) -> OEInteractionIter
        Prev(OEInteractionIter self, int i) -> OEInteractionIter
        """
        return _oequacpac.OEInteractionIter_Prev(self, *args)

# Register OEInteractionIter in _oequacpac:
_oequacpac.OEInteractionIter_swigregister(OEInteractionIter)

class OEInteraction(object):
    r"""Proxy of C++ OEMolPotential::OEInteraction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEInteraction self, OEMolPotential::OEInteractImpl & arg2) -> OEInteraction
        __init__(OEInteraction self, OEInteraction arg2) -> OEInteraction
        """
        _oequacpac.OEInteraction_swiginit(self, _oequacpac.new_OEInteraction(*args))
    __swig_destroy__ = _oequacpac.delete_OEInteraction

    def NumAtoms(self) -> "unsigned int":
        r"""NumAtoms(OEInteraction self) -> unsigned int"""
        return _oequacpac.OEInteraction_NumAtoms(self)

    def NumValues(self) -> "unsigned int":
        r"""NumValues(OEInteraction self) -> unsigned int"""
        return _oequacpac.OEInteraction_NumValues(self)

    def GetName(self) -> "std::string":
        r"""GetName(OEInteraction self) -> std::string"""
        return _oequacpac.OEInteraction_GetName(self)

    def GetValues(self, grads: "double *"=None) -> "double":
        r"""GetValues(OEInteraction self, double * grads=None) -> double"""
        return _oequacpac.OEInteraction_GetValues(self, grads)

    def GetAtoms(self) -> "OESystem::OEIterBase< OEChem::OEAtomBase > *":
        r"""GetAtoms(OEInteraction self) -> OESystem::OEIterBase< OEChem::OEAtomBase > *"""
        return _oequacpac.OEInteraction_GetAtoms(self)

    def GetImpl(self) -> "OEMolPotential::OEInteractImpl *":
        r"""GetImpl(OEInteraction self) -> OEMolPotential::OEInteractImpl *"""
        return _oequacpac.OEInteraction_GetImpl(self)

# Register OEInteraction in _oequacpac:
_oequacpac.OEInteraction_swigregister(OEInteraction)

class OEMolFunc(object):
    r"""Proxy of C++ OEMolPotential::OEMolFunc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEMolFunc

    def Setup(self, mol: "OEMolBase") -> "bool":
        r"""Setup(OEMolFunc self, OEMolBase mol) -> bool"""
        return _oequacpac.OEMolFunc_Setup(self, mol)

    def GetInteractions(self, arg2: "OEMolBase", arg3: "double const *", functype: "unsigned int"=0) -> "OESystem::OEIterBase< OEMolPotential::OEInteraction > *":
        r"""GetInteractions(OEMolFunc self, OEMolBase arg2, double const * arg3, unsigned int functype=0) -> OESystem::OEIterBase< OEMolPotential::OEInteraction >"""
        return _oequacpac.OEMolFunc_GetInteractions(self, arg2, arg3, functype)

    def SetVerbose(self, arg2: "bool") -> "void":
        r"""SetVerbose(OEMolFunc self, bool arg2)"""
        return _oequacpac.OEMolFunc_SetVerbose(self, arg2)

# Register OEMolFunc in _oequacpac:
_oequacpac.OEMolFunc_swigregister(OEMolFunc)

class OEMolFunc0(OEFunc0, OEMolFunc):
    r"""Proxy of C++ OEMolPotential::OEMolFunc0 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEMolFunc0

# Register OEMolFunc0 in _oequacpac:
_oequacpac.OEMolFunc0_swigregister(OEMolFunc0)

class OEMolFunc1(OEFunc1, OEMolFunc0):
    r"""Proxy of C++ OEMolPotential::OEMolFunc1 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEMolFunc1

    def CreateCopy(self) -> "OEMolPotential::OEMolFunc1 *":
        r"""CreateCopy(OEMolFunc1 self) -> OEMolFunc1"""
        return _oequacpac.OEMolFunc1_CreateCopy(self)

# Register OEMolFunc1 in _oequacpac:
_oequacpac.OEMolFunc1_swigregister(OEMolFunc1)

class OEMolFunc2(OEFunc2, OEMolFunc1):
    r"""Proxy of C++ OEMolPotential::OEMolFunc2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEMolFunc2

# Register OEMolFunc2 in _oequacpac:
_oequacpac.OEMolFunc2_swigregister(OEMolFunc2)

class OEForceField(OEMolFunc1):
    r"""Proxy of C++ OEMolPotential::OEForceField class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEForceField

    def PrepMol(self, mol: "OEMolBase", sweep: "bool"=True, warnOK: "bool"=True) -> "bool":
        r"""PrepMol(OEForceField self, OEMolBase mol, bool sweep=True, bool warnOK=True) -> bool"""
        return _oequacpac.OEForceField_PrepMol(self, mol, sweep, warnOK)

    def GetTitle(self) -> "std::string":
        r"""GetTitle(OEForceField self) -> std::string"""
        return _oequacpac.OEForceField_GetTitle(self)

    def SetTitle(self, argTitle: "std::string const &") -> "void":
        r"""SetTitle(OEForceField self, std::string const & argTitle)"""
        return _oequacpac.OEForceField_SetTitle(self, argTitle)

    def CreateCopy(self) -> "OEMolPotential::OEForceField *":
        r"""CreateCopy(OEForceField self) -> OEForceField"""
        return _oequacpac.OEForceField_CreateCopy(self)

    def Add(self, *args) -> "bool":
        r"""
        Add(OEForceField self, OEMolFunc1 f, bool own=False) -> bool
        Add(OEForceField self, OEMolPotential::OEFFParams const & ffp) -> bool
        """
        return _oequacpac.OEForceField_Add(self, *args)

    def Remove(self, f: "OEMolFunc1") -> "bool":
        r"""Remove(OEForceField self, OEMolFunc1 f) -> bool"""
        return _oequacpac.OEForceField_Remove(self, f)

    def GetComponentPotentials(self) -> "std::vector< OEMolPotential::OEMolFunc1 *,std::allocator< OEMolPotential::OEMolFunc1 * > >":
        r"""GetComponentPotentials(OEForceField self) -> std::vector< OEMolPotential::OEMolFunc1 *,std::allocator< OEMolPotential::OEMolFunc1 * > >"""
        return _oequacpac.OEForceField_GetComponentPotentials(self)

    def GetParams(self) -> "std::vector< OEMolPotential::OEFFParams const *,std::allocator< OEMolPotential::OEFFParams const * > >":
        r"""GetParams(OEForceField self) -> std::vector< OEMolPotential::OEFFParams const *,std::allocator< OEMolPotential::OEFFParams const * > >"""
        return _oequacpac.OEForceField_GetParams(self)

# Register OEForceField in _oequacpac:
_oequacpac.OEForceField_swigregister(OEForceField)

class OEGenericFF2(OEMolFunc2, OEForceField):
    r"""Proxy of C++ OEMolPotential::OEGenericFF2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEGenericFF2 self) -> OEGenericFF2
        __init__(OEGenericFF2 self, OEGenericFF2 arg2) -> OEGenericFF2
        """
        _oequacpac.OEGenericFF2_swiginit(self, _oequacpac.new_OEGenericFF2(*args))
    __swig_destroy__ = _oequacpac.delete_OEGenericFF2

    def NumVar(self) -> "unsigned int":
        r"""NumVar(OEGenericFF2 self) -> unsigned int"""
        return _oequacpac.OEGenericFF2_NumVar(self)

    def Setup(self, mol: "OEMolBase") -> "bool":
        r"""Setup(OEGenericFF2 self, OEMolBase mol) -> bool"""
        return _oequacpac.OEGenericFF2_Setup(self, mol)

    def __call__(self, *args) -> "bool":
        r"""
        __call__(OEGenericFF2 self, double const * coord) -> double
        __call__(OEGenericFF2 self, double const * coord, double * grad) -> double
        __call__(OEGenericFF2 self, double const * coord, double * hess, double * grad) -> bool
        """
        return _oequacpac.OEGenericFF2___call__(self, *args)

    def GetFComponents(self, coord: "double const *") -> "OESystem::OEIterBase< OEOpt::OEFComponent > *":
        r"""GetFComponents(OEGenericFF2 self, double const * coord) -> OESystem::OEIterBase< OEOpt::OEFComponent > *"""
        return _oequacpac.OEGenericFF2_GetFComponents(self, coord)

    def GetInteractions(self, mol: "OEMolBase", coord: "double const *", functype: "unsigned int"=0) -> "OESystem::OEIterBase< OEMolPotential::OEInteraction > *":
        r"""GetInteractions(OEGenericFF2 self, OEMolBase mol, double const * coord, unsigned int functype=0) -> OESystem::OEIterBase< OEMolPotential::OEInteraction >"""
        return _oequacpac.OEGenericFF2_GetInteractions(self, mol, coord, functype)

    def SetVerbose(self, arg2: "bool") -> "void":
        r"""SetVerbose(OEGenericFF2 self, bool arg2)"""
        return _oequacpac.OEGenericFF2_SetVerbose(self, arg2)

    def CreateCopy(self) -> "OEMolPotential::OEGenericFF2 *":
        r"""CreateCopy(OEGenericFF2 self) -> OEGenericFF2"""
        return _oequacpac.OEGenericFF2_CreateCopy(self)

    def PrepMol(self, mol: "OEMolBase", sweep: "bool"=True, warnOK: "bool"=True) -> "bool":
        r"""PrepMol(OEGenericFF2 self, OEMolBase mol, bool sweep=True, bool warnOK=True) -> bool"""
        return _oequacpac.OEGenericFF2_PrepMol(self, mol, sweep, warnOK)

    def Add(self, *args) -> "bool":
        r"""
        Add(OEGenericFF2 self, OEMolPotential::OEFFParams const & ffp) -> bool
        Add(OEGenericFF2 self, OEMolFunc1 func, bool own=False) -> bool
        """
        return _oequacpac.OEGenericFF2_Add(self, *args)

    def GetComponentPotentials(self) -> "std::vector< OEMolPotential::OEMolFunc1 *,std::allocator< OEMolPotential::OEMolFunc1 * > >":
        r"""GetComponentPotentials(OEGenericFF2 self) -> std::vector< OEMolPotential::OEMolFunc1 *,std::allocator< OEMolPotential::OEMolFunc1 * > >"""
        return _oequacpac.OEGenericFF2_GetComponentPotentials(self)

    def GetParams(self) -> "std::vector< OEMolPotential::OEFFParams const *,std::allocator< OEMolPotential::OEFFParams const * > >":
        r"""GetParams(OEGenericFF2 self) -> std::vector< OEMolPotential::OEFFParams const *,std::allocator< OEMolPotential::OEFFParams const * > >"""
        return _oequacpac.OEGenericFF2_GetParams(self)

    def AddMolFunc(self, f: "OEMolFunc2", own: "bool"=False) -> "bool":
        r"""AddMolFunc(OEGenericFF2 self, OEMolFunc2 f, bool own=False) -> bool"""
        return _oequacpac.OEGenericFF2_AddMolFunc(self, f, own)

    def RemoveMolFunc(self, f: "OEMolFunc2") -> "bool":
        r"""RemoveMolFunc(OEGenericFF2 self, OEMolFunc2 f) -> bool"""
        return _oequacpac.OEGenericFF2_RemoveMolFunc(self, f)

    def GetComponents(self) -> "std::vector< OEMolPotential::OEMolFunc2 *,std::allocator< OEMolPotential::OEMolFunc2 * > >":
        r"""GetComponents(OEGenericFF2 self) -> std::vector< OEMolPotential::OEMolFunc2 *,std::allocator< OEMolPotential::OEMolFunc2 * > >"""
        return _oequacpac.OEGenericFF2_GetComponents(self)

# Register OEGenericFF2 in _oequacpac:
_oequacpac.OEGenericFF2_swigregister(OEGenericFF2)

class OEGenericFF(OEForceField):
    r"""Proxy of C++ OEMolPotential::OEGenericFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEGenericFF self) -> OEGenericFF
        __init__(OEGenericFF self, OEGenericFF arg2) -> OEGenericFF
        __init__(OEGenericFF self, OEGenericFF2 arg2) -> OEGenericFF
        """
        _oequacpac.OEGenericFF_swiginit(self, _oequacpac.new_OEGenericFF(*args))
    __swig_destroy__ = _oequacpac.delete_OEGenericFF

    def NumVar(self) -> "unsigned int":
        r"""NumVar(OEGenericFF self) -> unsigned int"""
        return _oequacpac.OEGenericFF_NumVar(self)

    def Setup(self, mol: "OEMolBase") -> "bool":
        r"""Setup(OEGenericFF self, OEMolBase mol) -> bool"""
        return _oequacpac.OEGenericFF_Setup(self, mol)

    def __call__(self, *args) -> "double":
        r"""
        __call__(OEGenericFF self, double const * coord) -> double
        __call__(OEGenericFF self, double const * coord, double * grad) -> double
        """
        return _oequacpac.OEGenericFF___call__(self, *args)

    def GetFComponents(self, coord: "double const *") -> "OESystem::OEIterBase< OEOpt::OEFComponent > *":
        r"""GetFComponents(OEGenericFF self, double const * coord) -> OESystem::OEIterBase< OEOpt::OEFComponent > *"""
        return _oequacpac.OEGenericFF_GetFComponents(self, coord)

    def GetInteractions(self, mol: "OEMolBase", coord: "double const *", functype: "unsigned int"=0) -> "OESystem::OEIterBase< OEMolPotential::OEInteraction > *":
        r"""GetInteractions(OEGenericFF self, OEMolBase mol, double const * coord, unsigned int functype=0) -> OESystem::OEIterBase< OEMolPotential::OEInteraction >"""
        return _oequacpac.OEGenericFF_GetInteractions(self, mol, coord, functype)

    def SetVerbose(self, arg2: "bool") -> "void":
        r"""SetVerbose(OEGenericFF self, bool arg2)"""
        return _oequacpac.OEGenericFF_SetVerbose(self, arg2)

    def CreateCopy(self) -> "OEMolPotential::OEGenericFF *":
        r"""CreateCopy(OEGenericFF self) -> OEGenericFF"""
        return _oequacpac.OEGenericFF_CreateCopy(self)

    def PrepMol(self, mol: "OEMolBase", sweep: "bool"=True, warnOK: "bool"=True) -> "bool":
        r"""PrepMol(OEGenericFF self, OEMolBase mol, bool sweep=True, bool warnOK=True) -> bool"""
        return _oequacpac.OEGenericFF_PrepMol(self, mol, sweep, warnOK)

    def Add(self, *args) -> "bool":
        r"""
        Add(OEGenericFF self, OEMolFunc1 f, bool own=False) -> bool
        Add(OEGenericFF self, OEMolPotential::OEFFParams const & ffp) -> bool
        """
        return _oequacpac.OEGenericFF_Add(self, *args)

    def Remove(self, f: "OEMolFunc1") -> "bool":
        r"""Remove(OEGenericFF self, OEMolFunc1 f) -> bool"""
        return _oequacpac.OEGenericFF_Remove(self, f)

    def GetComponentPotentials(self) -> "std::vector< OEMolPotential::OEMolFunc1 *,std::allocator< OEMolPotential::OEMolFunc1 * > >":
        r"""GetComponentPotentials(OEGenericFF self) -> std::vector< OEMolPotential::OEMolFunc1 *,std::allocator< OEMolPotential::OEMolFunc1 * > >"""
        return _oequacpac.OEGenericFF_GetComponentPotentials(self)

    def GetParams(self) -> "std::vector< OEMolPotential::OEFFParams const *,std::allocator< OEMolPotential::OEFFParams const * > >":
        r"""GetParams(OEGenericFF self) -> std::vector< OEMolPotential::OEFFParams const *,std::allocator< OEMolPotential::OEFFParams const * > >"""
        return _oequacpac.OEGenericFF_GetParams(self)

    def AddMolFunc(self, f: "OEMolFunc1", own: "bool"=False) -> "bool":
        r"""AddMolFunc(OEGenericFF self, OEMolFunc1 f, bool own=False) -> bool"""
        return _oequacpac.OEGenericFF_AddMolFunc(self, f, own)

    def RemoveMolFunc(self, f: "OEMolFunc1") -> "bool":
        r"""RemoveMolFunc(OEGenericFF self, OEMolFunc1 f) -> bool"""
        return _oequacpac.OEGenericFF_RemoveMolFunc(self, f)

    def GetComponents(self) -> "std::vector< OEMolPotential::OEMolFunc1 *,std::allocator< OEMolPotential::OEMolFunc1 * > >":
        r"""GetComponents(OEGenericFF self) -> std::vector< OEMolPotential::OEMolFunc1 *,std::allocator< OEMolPotential::OEMolFunc1 * > >"""
        return _oequacpac.OEGenericFF_GetComponents(self)

# Register OEGenericFF in _oequacpac:
_oequacpac.OEGenericFF_swigregister(OEGenericFF)

class OEInterMolFunc1(OEMolFunc1):
    r"""Proxy of C++ OEMolPotential::OEInterMolFunc1 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEInterMolFunc1

    def SetupHost(self, host: "OEMolBase") -> "bool":
        r"""SetupHost(OEInterMolFunc1 self, OEMolBase host) -> bool"""
        return _oequacpac.OEInterMolFunc1_SetupHost(self, host)

    def SetHostFlex(self, pred: "OEUnaryAtomPred") -> "bool":
        r"""SetHostFlex(OEInterMolFunc1 self, OEUnaryAtomPred pred) -> bool"""
        return _oequacpac.OEInterMolFunc1_SetHostFlex(self, pred)

    def GetVar(self, var: "double *", x: "double const *") -> "void":
        r"""GetVar(OEInterMolFunc1 self, double * var, double const * x)"""
        return _oequacpac.OEInterMolFunc1_GetVar(self, var, x)

    def AdaptHostCoords(self, coords: "double *", var: "double const *") -> "bool":
        r"""AdaptHostCoords(OEInterMolFunc1 self, double * coords, double const * var) -> bool"""
        return _oequacpac.OEInterMolFunc1_AdaptHostCoords(self, coords, var)

# Register OEInterMolFunc1 in _oequacpac:
_oequacpac.OEInterMolFunc1_swigregister(OEInterMolFunc1)

class OEInterMolFunc2(OEInterMolFunc1, OEMolFunc2):
    r"""Proxy of C++ OEMolPotential::OEInterMolFunc2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEInterMolFunc2

# Register OEInterMolFunc2 in _oequacpac:
_oequacpac.OEInterMolFunc2_swigregister(OEInterMolFunc2)

class OEAM1Options(oechem.OEOptions):
    r"""Proxy of C++ OEMolAM1::OEAM1Options class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEAM1Options self) -> OEAM1Options
        __init__(OEAM1Options self, OEAM1Options arg2) -> OEAM1Options
        """
        _oequacpac.OEAM1Options_swiginit(self, _oequacpac.new_OEAM1Options(*args))
    __swig_destroy__ = _oequacpac.delete_OEAM1Options

    def GetSCFTolerance(self) -> "double":
        r"""GetSCFTolerance(OEAM1Options self) -> double"""
        return _oequacpac.OEAM1Options_GetSCFTolerance(self)

    def SetSCFTolerance(self, value: "double const") -> "bool":
        r"""SetSCFTolerance(OEAM1Options self, double const value) -> bool"""
        return _oequacpac.OEAM1Options_SetSCFTolerance(self, value)

    def GetNumericGradDelta(self) -> "double":
        r"""GetNumericGradDelta(OEAM1Options self) -> double"""
        return _oequacpac.OEAM1Options_GetNumericGradDelta(self)

    def SetNumericGradDelta(self, value: "double const") -> "bool":
        r"""SetNumericGradDelta(OEAM1Options self, double const value) -> bool"""
        return _oequacpac.OEAM1Options_SetNumericGradDelta(self, value)

    def GetMaxScfIter(self) -> "unsigned int":
        r"""GetMaxScfIter(OEAM1Options self) -> unsigned int"""
        return _oequacpac.OEAM1Options_GetMaxScfIter(self)

    def SetMaxScfIter(self, value: "unsigned int const") -> "bool":
        r"""SetMaxScfIter(OEAM1Options self, unsigned int const value) -> bool"""
        return _oequacpac.OEAM1Options_SetMaxScfIter(self, value)

    def GetSemiMethod(self) -> "unsigned int":
        r"""GetSemiMethod(OEAM1Options self) -> unsigned int"""
        return _oequacpac.OEAM1Options_GetSemiMethod(self)

    def SetSemiMethod(self, value: "unsigned int const") -> "bool":
        r"""SetSemiMethod(OEAM1Options self, unsigned int const value) -> bool"""
        return _oequacpac.OEAM1Options_SetSemiMethod(self, value)

    def CreateCopy(self) -> "OEMolAM1::OEAM1Options *":
        r"""CreateCopy(OEAM1Options self) -> OEAM1Options"""
        return _oequacpac.OEAM1Options_CreateCopy(self)

# Register OEAM1Options in _oequacpac:
_oequacpac.OEAM1Options_swigregister(OEAM1Options)

class OEAM1Results(object):
    r"""Proxy of C++ OEMolAM1::OEAM1Results class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEAM1Results self) -> OEAM1Results
        __init__(OEAM1Results self, OEAM1Results arg2) -> OEAM1Results
        """
        _oequacpac.OEAM1Results_swiginit(self, _oequacpac.new_OEAM1Results(*args))
    __swig_destroy__ = _oequacpac.delete_OEAM1Results

    def GetCharges(self) -> "std::vector< double,std::allocator< double > >":
        r"""GetCharges(OEAM1Results self) -> OEDoubleVector"""
        return _oequacpac.OEAM1Results_GetCharges(self)

    def GetBondOrders(self) -> "std::vector< double,std::allocator< double > >":
        r"""GetBondOrders(OEAM1Results self) -> OEDoubleVector"""
        return _oequacpac.OEAM1Results_GetBondOrders(self)

    def GetBondOrder(self, argAtom1: "unsigned int const", argAtom2: "unsigned int const") -> "double":
        r"""GetBondOrder(OEAM1Results self, unsigned int const argAtom1, unsigned int const argAtom2) -> double"""
        return _oequacpac.OEAM1Results_GetBondOrder(self, argAtom1, argAtom2)

    def GetAtomicBondOrder(self, argAtom: "unsigned int const") -> "double":
        r"""GetAtomicBondOrder(OEAM1Results self, unsigned int const argAtom) -> double"""
        return _oequacpac.OEAM1Results_GetAtomicBondOrder(self, argAtom)

    def GetEnergy(self) -> "double":
        r"""GetEnergy(OEAM1Results self) -> double"""
        return _oequacpac.OEAM1Results_GetEnergy(self)

    def GetNumSCFCycles(self) -> "unsigned int":
        r"""GetNumSCFCycles(OEAM1Results self) -> unsigned int"""
        return _oequacpac.OEAM1Results_GetNumSCFCycles(self)

    def IsConverged(self) -> "bool":
        r"""IsConverged(OEAM1Results self) -> bool"""
        return _oequacpac.OEAM1Results_IsConverged(self)

# Register OEAM1Results in _oequacpac:
_oequacpac.OEAM1Results_swigregister(OEAM1Results)

class OEAM1(OEMolFunc1):
    r"""Proxy of C++ OEMolAM1::OEAM1 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEAM1

    def __init__(self, *args):
        r"""
        __init__(OEAM1 self, OEAM1Options argOptions=OEMolAM1::OEAM1Options()) -> OEAM1
        __init__(OEAM1 self, OEAM1 arg2) -> OEAM1
        """
        _oequacpac.OEAM1_swiginit(self, _oequacpac.new_OEAM1(*args))

    def Setup(self, mol: "OEMolBase") -> "bool":
        r"""Setup(OEAM1 self, OEMolBase mol) -> bool"""
        return _oequacpac.OEAM1_Setup(self, mol)

    def NumVar(self) -> "unsigned int":
        r"""NumVar(OEAM1 self) -> unsigned int"""
        return _oequacpac.OEAM1_NumVar(self)

    def SetVerbose(self, ver: "bool") -> "void":
        r"""SetVerbose(OEAM1 self, bool ver)"""
        return _oequacpac.OEAM1_SetVerbose(self, ver)

    def GetFComponents(self, arg2: "double const *") -> "OESystem::OEIterBase< OEOpt::OEFComponent > *":
        r"""GetFComponents(OEAM1 self, double const * arg2) -> OESystem::OEIterBase< OEOpt::OEFComponent > *"""
        return _oequacpac.OEAM1_GetFComponents(self, arg2)

    def __call__(self, *args) -> "double":
        r"""
        __call__(OEAM1 self, double const * x) -> double
        __call__(OEAM1 self, double const * x, double * g) -> double
        """
        return _oequacpac.OEAM1___call__(self, *args)

    def CreateCopy(self) -> "OEMolAM1::OEAM1 *":
        r"""CreateCopy(OEAM1 self) -> OEAM1"""
        return _oequacpac.OEAM1_CreateCopy(self)

    def GetOptions(self) -> "OEMolAM1::OEAM1Options const &":
        r"""GetOptions(OEAM1 self) -> OEAM1Options"""
        return _oequacpac.OEAM1_GetOptions(self)

    def CalcAM1(self, argResults: "OEAM1Results", argMolecule: "OEMolBase") -> "bool":
        r"""CalcAM1(OEAM1 self, OEAM1Results argResults, OEMolBase argMolecule) -> bool"""
        return _oequacpac.OEAM1_CalcAM1(self, argResults, argMolecule)

    def GetResults(self, argResults: "OEAM1Results") -> "bool":
        r"""GetResults(OEAM1 self, OEAM1Results argResults) -> bool"""
        return _oequacpac.OEAM1_GetResults(self, argResults)

# Register OEAM1 in _oequacpac:
_oequacpac.OEAM1_swigregister(OEAM1)

class OEOptimizedAM1(object):
    r"""Proxy of C++ OEMolAM1::OEOptimizedAM1 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEOptimizedAM1 self, unsigned int wvnFnType=OEMethodType::AM1) -> OEOptimizedAM1
        __init__(OEOptimizedAM1 self, OEOptimizedAM1 arg2) -> OEOptimizedAM1
        """
        _oequacpac.OEOptimizedAM1_swiginit(self, _oequacpac.new_OEOptimizedAM1(*args))
    __swig_destroy__ = _oequacpac.delete_OEOptimizedAM1

    def CalcAM1(self, *args) -> "bool":
        r"""
        CalcAM1(OEOptimizedAM1 self, OEAM1Results results, OEMolBase mol) -> bool
        CalcAM1(OEOptimizedAM1 self, OEAM1Results results, OEMCMolBase mol) -> bool
        """
        return _oequacpac.OEOptimizedAM1_CalcAM1(self, *args)

# Register OEOptimizedAM1 in _oequacpac:
_oequacpac.OEOptimizedAM1_swigregister(OEOptimizedAM1)


def OEBCCPartialCharges(*args) -> "bool":
    r"""OEBCCPartialCharges(OEMolBase mol, unsigned int BCCModel=, bool permissive=False, bool verbose=False) -> bool"""
    return _oequacpac.OEBCCPartialCharges(*args)

def OESymmetrizePartialCharges(mol: "OEMolBase") -> "bool":
    r"""OESymmetrizePartialCharges(OEMolBase mol) -> bool"""
    return _oequacpac.OESymmetrizePartialCharges(mol)
class OEELFOptions(oechem.OEOptions):
    r"""Proxy of C++ OEProton::OEELFOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEELFOptions self) -> OEELFOptions
        __init__(OEELFOptions self, OEELFOptions arg2) -> OEELFOptions
        """
        _oequacpac.OEELFOptions_swiginit(self, _oequacpac.new_OEELFOptions(*args))
    __swig_destroy__ = _oequacpac.delete_OEELFOptions

    def GetPercent(self) -> "double":
        r"""GetPercent(OEELFOptions self) -> double"""
        return _oequacpac.OEELFOptions_GetPercent(self)

    def SetPercent(self, value: "double const") -> "bool":
        r"""SetPercent(OEELFOptions self, double const value) -> bool"""
        return _oequacpac.OEELFOptions_SetPercent(self, value)

    def GetElfLimit(self) -> "unsigned int":
        r"""GetElfLimit(OEELFOptions self) -> unsigned int"""
        return _oequacpac.OEELFOptions_GetElfLimit(self)

    def SetElfLimit(self, value: "unsigned int const") -> "bool":
        r"""SetElfLimit(OEELFOptions self, unsigned int const value) -> bool"""
        return _oequacpac.OEELFOptions_SetElfLimit(self, value)

    def CreateCopy(self) -> "OEProton::OEELFOptions *":
        r"""CreateCopy(OEELFOptions self) -> OEELFOptions"""
        return _oequacpac.OEELFOptions_CreateCopy(self)

# Register OEELFOptions in _oequacpac:
_oequacpac.OEELFOptions_swigregister(OEELFOptions)

class OEELF(object):
    r"""Proxy of C++ OEProton::OEELF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEELF self, OEELFOptions opts=OEProton::OEELFOptions()) -> OEELF
        __init__(OEELF self, OEELF arg2) -> OEELF
        """
        _oequacpac.OEELF_swiginit(self, _oequacpac.new_OEELF(*args))
    __swig_destroy__ = _oequacpac.delete_OEELF

    def Select(self, mol: "OEMCMolBase") -> "bool":
        r"""Select(OEELF self, OEMCMolBase mol) -> bool"""
        return _oequacpac.OEELF_Select(self, mol)

# Register OEELF in _oequacpac:
_oequacpac.OEELF_swigregister(OEELF)

class OEFormalChargeOptions(object):
    r"""Proxy of C++ OEProton::OEFormalChargeOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEFormalChargeOptions self, unsigned int maxCount=0, bool verbose=False, bool warts=True) -> OEFormalChargeOptions
        __init__(OEFormalChargeOptions self, OEFormalChargeOptions rhs) -> OEFormalChargeOptions
        """
        _oequacpac.OEFormalChargeOptions_swiginit(self, _oequacpac.new_OEFormalChargeOptions(*args))
    __swig_destroy__ = _oequacpac.delete_OEFormalChargeOptions

    def GetMaxCount(self) -> "unsigned int":
        r"""GetMaxCount(OEFormalChargeOptions self) -> unsigned int"""
        return _oequacpac.OEFormalChargeOptions_GetMaxCount(self)

    def SetMaxCount(self, max: "unsigned int") -> "void":
        r"""SetMaxCount(OEFormalChargeOptions self, unsigned int max)"""
        return _oequacpac.OEFormalChargeOptions_SetMaxCount(self, max)

    def GetVerbose(self) -> "bool":
        r"""GetVerbose(OEFormalChargeOptions self) -> bool"""
        return _oequacpac.OEFormalChargeOptions_GetVerbose(self)

    def SetVerbose(self, verbose: "bool") -> "void":
        r"""SetVerbose(OEFormalChargeOptions self, bool verbose)"""
        return _oequacpac.OEFormalChargeOptions_SetVerbose(self, verbose)

    def GetWarts(self) -> "bool":
        r"""GetWarts(OEFormalChargeOptions self) -> bool"""
        return _oequacpac.OEFormalChargeOptions_GetWarts(self)

    def SetWarts(self, warts: "bool") -> "void":
        r"""SetWarts(OEFormalChargeOptions self, bool warts)"""
        return _oequacpac.OEFormalChargeOptions_SetWarts(self, warts)

# Register OEFormalChargeOptions in _oequacpac:
_oequacpac.OEFormalChargeOptions_swigregister(OEFormalChargeOptions)


def OESetNeutralpHModel(*args) -> "bool":
    r"""
    OESetNeutralpHModel(OEMolBase mol) -> bool
    OESetNeutralpHModel(OEMCMolBase mol) -> bool
    """
    return _oequacpac.OESetNeutralpHModel(*args)

def OERemoveFormalCharge(*args) -> "bool":
    r"""
    OERemoveFormalCharge(OEMolBase mol) -> bool
    OERemoveFormalCharge(OEMCMolBase mol) -> bool
    """
    return _oequacpac.OERemoveFormalCharge(*args)

def OEGetReasonableProtomer(*args) -> "bool":
    r"""
    OEGetReasonableProtomer(OEMolBase mol) -> bool
    OEGetReasonableProtomer(OEMCMolBase mol) -> bool
    """
    return _oequacpac.OEGetReasonableProtomer(*args)

def OEGetReasonableProtomers(*args) -> "OESystem::OEIterBase< OEChem::OEMCMolBase > *":
    r"""
    OEGetReasonableProtomers(OEMolBase mol) -> OESystem::OEIterBase< OEChem::OEMolBase >
    OEGetReasonableProtomers(OEMCMolBase mol) -> OESystem::OEIterBase< OEChem::OEMCMolBase > *
    """
    return _oequacpac.OEGetReasonableProtomers(*args)
class OETautomerOptions(object):
    r"""Proxy of C++ OEProton::OETautomerOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OETautomerOptions self, unsigned int maxGenerated=4096, bool rank=True, bool warts=False, unsigned int level=0, bool carbonHybrid=True, bool saveStereo=False, unsigned int maxZoneSize=35, unsigned int maxTautomericAtoms=70, float maxTime=120, bool kekule=False, bool clearCoords=False, unsigned int hybridLevel=, unsigned int maxToReturn=256, unsigned int racemicType=) -> OETautomerOptions
        __init__(OETautomerOptions self, OETautomerOptions rhs) -> OETautomerOptions
        """
        _oequacpac.OETautomerOptions_swiginit(self, _oequacpac.new_OETautomerOptions(*args))

    def GetMaxTautomersGenerated(self) -> "unsigned int":
        r"""GetMaxTautomersGenerated(OETautomerOptions self) -> unsigned int"""
        return _oequacpac.OETautomerOptions_GetMaxTautomersGenerated(self)

    def SetMaxTautomersGenerated(self, max: "unsigned int") -> "void":
        r"""SetMaxTautomersGenerated(OETautomerOptions self, unsigned int max)"""
        return _oequacpac.OETautomerOptions_SetMaxTautomersGenerated(self, max)

    def GetMaxTautomersToReturn(self) -> "unsigned int":
        r"""GetMaxTautomersToReturn(OETautomerOptions self) -> unsigned int"""
        return _oequacpac.OETautomerOptions_GetMaxTautomersToReturn(self)

    def SetMaxTautomersToReturn(self, max: "unsigned int") -> "void":
        r"""SetMaxTautomersToReturn(OETautomerOptions self, unsigned int max)"""
        return _oequacpac.OETautomerOptions_SetMaxTautomersToReturn(self, max)

    def GetRankTautomers(self) -> "bool":
        r"""GetRankTautomers(OETautomerOptions self) -> bool"""
        return _oequacpac.OETautomerOptions_GetRankTautomers(self)

    def SetRankTautomers(self, rank: "bool") -> "void":
        r"""SetRankTautomers(OETautomerOptions self, bool rank)"""
        return _oequacpac.OETautomerOptions_SetRankTautomers(self, rank)

    def GetApplyWarts(self) -> "bool":
        r"""GetApplyWarts(OETautomerOptions self) -> bool"""
        return _oequacpac.OETautomerOptions_GetApplyWarts(self)

    def SetApplyWarts(self, warts: "bool") -> "void":
        r"""SetApplyWarts(OETautomerOptions self, bool warts)"""
        return _oequacpac.OETautomerOptions_SetApplyWarts(self, warts)

    def GetLevel(self) -> "unsigned int":
        r"""GetLevel(OETautomerOptions self) -> unsigned int"""
        return _oequacpac.OETautomerOptions_GetLevel(self)

    def SetLevel(self, level: "unsigned int") -> "void":
        r"""SetLevel(OETautomerOptions self, unsigned int level)"""
        return _oequacpac.OETautomerOptions_SetLevel(self, level)

    def GetCarbonHybridization(self) -> "bool":
        r"""GetCarbonHybridization(OETautomerOptions self) -> bool"""
        return _oequacpac.OETautomerOptions_GetCarbonHybridization(self)

    def SetCarbonHybridization(self, carbonHybrid: "bool") -> "void":
        r"""SetCarbonHybridization(OETautomerOptions self, bool carbonHybrid)"""
        return _oequacpac.OETautomerOptions_SetCarbonHybridization(self, carbonHybrid)

    def GetHybridizationLevel(self) -> "unsigned int":
        r"""GetHybridizationLevel(OETautomerOptions self) -> unsigned int"""
        return _oequacpac.OETautomerOptions_GetHybridizationLevel(self)

    def SetHybridizationLevel(self, level: "unsigned int") -> "void":
        r"""SetHybridizationLevel(OETautomerOptions self, unsigned int level)"""
        return _oequacpac.OETautomerOptions_SetHybridizationLevel(self, level)

    def GetSaveStereo(self) -> "bool":
        r"""GetSaveStereo(OETautomerOptions self) -> bool"""
        return _oequacpac.OETautomerOptions_GetSaveStereo(self)

    def SetSaveStereo(self, saveStereo: "bool") -> "void":
        r"""SetSaveStereo(OETautomerOptions self, bool saveStereo)"""
        return _oequacpac.OETautomerOptions_SetSaveStereo(self, saveStereo)

    def GetRacemicType(self) -> "unsigned int":
        r"""GetRacemicType(OETautomerOptions self) -> unsigned int"""
        return _oequacpac.OETautomerOptions_GetRacemicType(self)

    def SetRacemicType(self, raceType: "unsigned int") -> "void":
        r"""SetRacemicType(OETautomerOptions self, unsigned int raceType)"""
        return _oequacpac.OETautomerOptions_SetRacemicType(self, raceType)

    def GetMaxZoneSize(self) -> "unsigned int":
        r"""GetMaxZoneSize(OETautomerOptions self) -> unsigned int"""
        return _oequacpac.OETautomerOptions_GetMaxZoneSize(self)

    def SetMaxZoneSize(self, maxZoneSize: "unsigned int") -> "void":
        r"""SetMaxZoneSize(OETautomerOptions self, unsigned int maxZoneSize)"""
        return _oequacpac.OETautomerOptions_SetMaxZoneSize(self, maxZoneSize)

    def GetMaxTautomericAtoms(self) -> "unsigned int":
        r"""GetMaxTautomericAtoms(OETautomerOptions self) -> unsigned int"""
        return _oequacpac.OETautomerOptions_GetMaxTautomericAtoms(self)

    def SetMaxTautomericAtoms(self, maxTautomericAtoms: "unsigned int") -> "void":
        r"""SetMaxTautomericAtoms(OETautomerOptions self, unsigned int maxTautomericAtoms)"""
        return _oequacpac.OETautomerOptions_SetMaxTautomericAtoms(self, maxTautomericAtoms)

    def GetMaxSearchTime(self) -> "float":
        r"""GetMaxSearchTime(OETautomerOptions self) -> float"""
        return _oequacpac.OETautomerOptions_GetMaxSearchTime(self)

    def SetMaxSearchTime(self, maxTime: "float") -> "void":
        r"""SetMaxSearchTime(OETautomerOptions self, float maxTime)"""
        return _oequacpac.OETautomerOptions_SetMaxSearchTime(self, maxTime)

    def GetKekule(self) -> "bool":
        r"""GetKekule(OETautomerOptions self) -> bool"""
        return _oequacpac.OETautomerOptions_GetKekule(self)

    def SetKekule(self, kekule: "bool") -> "void":
        r"""SetKekule(OETautomerOptions self, bool kekule)"""
        return _oequacpac.OETautomerOptions_SetKekule(self, kekule)

    def GetClearCoords(self) -> "bool":
        r"""GetClearCoords(OETautomerOptions self) -> bool"""
        return _oequacpac.OETautomerOptions_GetClearCoords(self)

    def SetClearCoords(self, clearCoords: "bool") -> "void":
        r"""SetClearCoords(OETautomerOptions self, bool clearCoords)"""
        return _oequacpac.OETautomerOptions_SetClearCoords(self, clearCoords)
    __swig_destroy__ = _oequacpac.delete_OETautomerOptions

# Register OETautomerOptions in _oequacpac:
_oequacpac.OETautomerOptions_swigregister(OETautomerOptions)


def OETautomersLargestZoneSize(*args) -> "unsigned int":
    r"""
    OETautomersLargestZoneSize(OEMolBase mol, OETautomerOptions tautomerOptions) -> unsigned int
    OETautomersLargestZoneSize(OEMolBase inmol, unsigned int maxZone=0) -> unsigned int
    """
    return _oequacpac.OETautomersLargestZoneSize(*args)

def OEGetReasonableTautomers(*args) -> "OESystem::OEIterBase< OEChem::OEMCMolBase > *":
    r"""
    OEGetReasonableTautomers(OEMolBase mol, OETautomerOptions opts=OEProton::OETautomerOptions(), bool pKaNorm=True) -> OESystem::OEIterBase< OEChem::OEMolBase >
    OEGetReasonableTautomers(OEMCMolBase mol, OETautomerOptions opts=OEProton::OETautomerOptions(), bool pKaNorm=True) -> OESystem::OEIterBase< OEChem::OEMCMolBase >
    """
    return _oequacpac.OEGetReasonableTautomers(*args)

def OEGetUniqueProtomer(*args) -> "bool":
    r"""
    OEGetUniqueProtomer(OEMolBase dst, OEMolBase mol) -> bool
    OEGetUniqueProtomer(OEMCMolBase dst, OEMCMolBase mol) -> bool
    """
    return _oequacpac.OEGetUniqueProtomer(*args)

def OEHypervalentNormalization(mol: "OEMolBase") -> "void":
    r"""OEHypervalentNormalization(OEMolBase mol)"""
    return _oequacpac.OEHypervalentNormalization(mol)
class OETautomerMolFunction(OEMolFunctionBase):
    r"""Proxy of C++ OEProton::OETautomerMolFunction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ofp: "oemolostream", arom: "bool", ct: "bool"=False, max: "unsigned int"=0, mostAro: "bool"=False, warts: "bool"=True):
        r"""__init__(OETautomerMolFunction self, oemolostream ofp, bool arom, bool ct=False, unsigned int max=0, bool mostAro=False, bool warts=True) -> OETautomerMolFunction"""
        if self.__class__ == OETautomerMolFunction:
            _self = None
        else:
            _self = self
        _oequacpac.OETautomerMolFunction_swiginit(self, _oequacpac.new_OETautomerMolFunction(_self, ofp, arom, ct, max, mostAro, warts))
    __swig_destroy__ = _oequacpac.delete_OETautomerMolFunction

    def CreateCopy(self) -> "OEProton::OEMolFunctionBase *":
        r"""CreateCopy(OETautomerMolFunction self) -> OEMolFunctionBase"""
        return _oequacpac.OETautomerMolFunction_CreateCopy(self)

    def __call__(self, inmol: "OEMolBase") -> "bool":
        r"""__call__(OETautomerMolFunction self, OEMolBase inmol) -> bool"""
        return _oequacpac.OETautomerMolFunction___call__(self, inmol)

    def Reset(self) -> "void":
        r"""Reset(OETautomerMolFunction self)"""
        return _oequacpac.OETautomerMolFunction_Reset(self)

    def GetCount(self) -> "unsigned int":
        r"""GetCount(OETautomerMolFunction self) -> unsigned int"""
        return _oequacpac.OETautomerMolFunction_GetCount(self)

    def GetMolecule(self) -> "OEChem::OEMolBase const &":
        r"""GetMolecule(OETautomerMolFunction self) -> OEMolBase"""
        return _oequacpac.OETautomerMolFunction_GetMolecule(self)
    def __disown__(self):
        self.this.disown()
        _oequacpac.disown_OETautomerMolFunction(self)
        return weakref.proxy(self)

# Register OETautomerMolFunction in _oequacpac:
_oequacpac.OETautomerMolFunction_swigregister(OETautomerMolFunction)


def OEEnumerateTautomers(*args) -> "unsigned int":
    r"""
    OEEnumerateTautomers(OEMolBase mol, OETautomerOptions tautomerOptions) -> OESystem::OEIterBase< OEChem::OEMolBase >
    OEEnumerateTautomers(OEMCMolBase mol, OETautomerOptions tautomerOptions) -> OESystem::OEIterBase< OEChem::OEMCMolBase >
    OEEnumerateTautomers(OEMolBase mol, OEMolFunctionBase mfb, unsigned int allflag=0, bool ch3flag=False, bool saveStereo=False, float maxTime=120) -> unsigned int
    """
    return _oequacpac.OEEnumerateTautomers(*args)

def OEGetChargeTypeName(chargeType: "unsigned int") -> "char const *":
    r"""OEGetChargeTypeName(unsigned int chargeType) -> char const *"""
    return _oequacpac.OEGetChargeTypeName(chargeType)

def OEAssignPartialCharges(*args) -> "bool":
    r"""
    OEAssignPartialCharges(OEMolBase mol, unsigned int method=, bool noHydrogen=False, bool debug=False, bool epsilon2=False) -> bool
    OEAssignPartialCharges(OEMCMolBase mol, unsigned int method=, bool noHydrogen=False, bool debug=False, bool epsilon2=False) -> bool
    """
    return _oequacpac.OEAssignPartialCharges(*args)
OE_OEQUACPAC_VERSION = _oequacpac.OE_OEQUACPAC_VERSION


def OEQuacPacGetRelease() -> "char const *":
    r"""OEQuacPacGetRelease() -> char const *"""
    return _oequacpac.OEQuacPacGetRelease()

def OEQuacPacGetVersion() -> "unsigned int":
    r"""OEQuacPacGetVersion() -> unsigned int"""
    return _oequacpac.OEQuacPacGetVersion()

def OEQuacPacGetArch() -> "char const *":
    r"""OEQuacPacGetArch() -> char const *"""
    return _oequacpac.OEQuacPacGetArch()

def OEQuacPacGetPlatform() -> "char const *":
    r"""OEQuacPacGetPlatform() -> char const *"""
    return _oequacpac.OEQuacPacGetPlatform()

def OEQuacPacIsLicensed(feature: "char const *"=None, expdate: "unsigned int *"=None) -> "bool":
    r"""OEQuacPacIsLicensed(char const * feature=None, unsigned int * expdate=None) -> bool"""
    return _oequacpac.OEQuacPacIsLicensed(feature, expdate)

def OEQuacPacGetLicensee(*args) -> "std::string":
    r"""
    OEQuacPacGetLicensee(std::string & licensee) -> bool
    OEQuacPacGetLicensee() -> std::string
    """
    return _oequacpac.OEQuacPacGetLicensee(*args)

def OEQuacPacGetSite(*args) -> "std::string":
    r"""
    OEQuacPacGetSite(std::string & site) -> bool
    OEQuacPacGetSite() -> std::string
    """
    return _oequacpac.OEQuacPacGetSite(*args)
class OETyperMolFunction(OEMolFunctionBase):
    r"""Proxy of C++ OEProton::OETyperMolFunction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ofp: "oemolostream", arom: "bool", ct: "bool"=False, max: "unsigned int"=0):
        r"""__init__(OETyperMolFunction self, oemolostream ofp, bool arom, bool ct=False, unsigned int max=0) -> OETyperMolFunction"""
        if self.__class__ == OETyperMolFunction:
            _self = None
        else:
            _self = self
        _oequacpac.OETyperMolFunction_swiginit(self, _oequacpac.new_OETyperMolFunction(_self, ofp, arom, ct, max))

    def Reset(self) -> "void":
        r"""Reset(OETyperMolFunction self)"""
        return _oequacpac.OETyperMolFunction_Reset(self)

    def __call__(self, inmol: "OEMolBase") -> "bool":
        r"""__call__(OETyperMolFunction self, OEMolBase inmol) -> bool"""
        return _oequacpac.OETyperMolFunction___call__(self, inmol)

    def CreateCopy(self) -> "OESystem::OEUnaryFunction< OEChem::OEMolBase,bool,true,false >::base_type *":
        r"""CreateCopy(OETyperMolFunction self) -> OEMolFunctionBase"""
        return _oequacpac.OETyperMolFunction_CreateCopy(self)
    __swig_destroy__ = _oequacpac.delete_OETyperMolFunction
    def __disown__(self):
        self.this.disown()
        _oequacpac.disown_OETyperMolFunction(self)
        return weakref.proxy(self)

# Register OETyperMolFunction in _oequacpac:
_oequacpac.OETyperMolFunction_swigregister(OETyperMolFunction)


def OEEnumerateFormalCharges(*args) -> "unsigned int":
    r"""
    OEEnumerateFormalCharges(OEMolBase mol, OEFormalChargeOptions formalChargeOptions=OEProton::OEFormalChargeOptions()) -> OESystem::OEIterBase< OEChem::OEMolBase >
    OEEnumerateFormalCharges(OEMCMolBase mol, OEFormalChargeOptions formalChargeOptions=OEProton::OEFormalChargeOptions()) -> OESystem::OEIterBase< OEChem::OEMolBase >
    OEEnumerateFormalCharges(OEMolBase mol, OEMolFunctionBase mfb, bool verbose=False) -> unsigned int
    """
    return _oequacpac.OEEnumerateFormalCharges(*args)
class OEChargeEngineBase(object):
    r"""Proxy of C++ OEProton::OEChargeEngineBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEChargeEngineBase

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEChargeEngineBase self) -> OEChargeEngineBase"""
        return _oequacpac.OEChargeEngineBase_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEChargeEngineBase self) -> unsigned int"""
        return _oequacpac.OEChargeEngineBase_GetChargeType(self)

    def __eq__(self, rhs: "OEChargeEngineBase") -> "bool":
        r"""__eq__(OEChargeEngineBase self, OEChargeEngineBase rhs) -> bool"""
        return _oequacpac.OEChargeEngineBase___eq__(self, rhs)

    def __ne__(self, rhs: "OEChargeEngineBase") -> "bool":
        r"""__ne__(OEChargeEngineBase self, OEChargeEngineBase rhs) -> bool"""
        return _oequacpac.OEChargeEngineBase___ne__(self, rhs)

    def GetName(self) -> "std::string":
        r"""GetName(OEChargeEngineBase self) -> std::string"""
        return _oequacpac.OEChargeEngineBase_GetName(self)

    def GetRequirements(self) -> "unsigned int":
        r"""GetRequirements(OEChargeEngineBase self) -> unsigned int"""
        return _oequacpac.OEChargeEngineBase_GetRequirements(self)

    def GetRepairRequestedHint(self) -> "bool":
        r"""GetRepairRequestedHint(OEChargeEngineBase self) -> bool"""
        return _oequacpac.OEChargeEngineBase_GetRepairRequestedHint(self)

    def GetExpectValidMol(self) -> "bool":
        r"""GetExpectValidMol(OEChargeEngineBase self) -> bool"""
        return _oequacpac.OEChargeEngineBase_GetExpectValidMol(self)

    def SetRepairRequestedHint(self, repair: "bool"=True) -> "void":
        r"""SetRepairRequestedHint(OEChargeEngineBase self, bool repair=True)"""
        return _oequacpac.OEChargeEngineBase_SetRepairRequestedHint(self, repair)

    def SetExpectValidMol(self, expect: "bool"=True) -> "void":
        r"""SetExpectValidMol(OEChargeEngineBase self, bool expect=True)"""
        return _oequacpac.OEChargeEngineBase_SetExpectValidMol(self, expect)

    def IsValid(self, *args) -> "bool":
        r"""
        IsValid(OEChargeEngineBase self, OEMolBase mol) -> bool
        IsValid(OEChargeEngineBase self, OEMCMolBase mcMol) -> bool
        IsValid(OEChargeEngineBase self, OEDesignUnit du) -> bool
        IsValid(OEChargeEngineBase self, OEDesignUnit du) -> bool
        """
        return _oequacpac.OEChargeEngineBase_IsValid(self, *args)

    def ApplyCharges(self, du: "OEDesignUnit") -> "bool":
        r"""ApplyCharges(OEChargeEngineBase self, OEDesignUnit du) -> bool"""
        return _oequacpac.OEChargeEngineBase_ApplyCharges(self, du)

    def CheckCharges(self, *args) -> "bool":
        r"""
        CheckCharges(OEChargeEngineBase self, OEMolBase mol) -> bool
        CheckCharges(OEChargeEngineBase self, OEMCMolBase mcMol) -> bool
        CheckCharges(OEChargeEngineBase self, OEDesignUnit du) -> bool
        """
        return _oequacpac.OEChargeEngineBase_CheckCharges(self, *args)

    def TransferCharge(self, dstAtom: "OEAtomBase", srcAtom: "OEAtomBase") -> "bool":
        r"""TransferCharge(OEChargeEngineBase self, OEAtomBase dstAtom, OEAtomBase srcAtom) -> bool"""
        return _oequacpac.OEChargeEngineBase_TransferCharge(self, dstAtom, srcAtom)

# Register OEChargeEngineBase in _oequacpac:
_oequacpac.OEChargeEngineBase_swigregister(OEChargeEngineBase)
cvar = _oequacpac.cvar
Nothing = cvar.Nothing
ResPerceived = cvar.ResPerceived
BondedResidues = cvar.BondedResidues
StandardResidues = cvar.StandardResidues
AltersResidueName = cvar.AltersResidueName
PDBOrder = cvar.PDBOrder
ExplicitHydrogens = cvar.ExplicitHydrogens
SetsAromaticity = cvar.SetsAromaticity
SetsType = cvar.SetsType
Parameters = cvar.Parameters
Coords3D = cvar.Coords3D
Compact = cvar.Compact
SizeWithinLimits = cvar.SizeWithinLimits
MultiConfOnly = cvar.MultiConfOnly
Precharged = cvar.Precharged
MolComplexPrep = cvar.MolComplexPrep
ReturnSelectedConfs = cvar.ReturnSelectedConfs

class OEChargeParameter(object):
    r"""Proxy of C++ OEProton::OEChargeParameter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OEChargeParameter self, std::string const & name) -> OEChargeParameter
        __init__(OEChargeParameter self) -> OEChargeParameter
        __init__(OEChargeParameter self, OEChargeParameter arg2) -> OEChargeParameter
        """
        _oequacpac.OEChargeParameter_swiginit(self, _oequacpac.new_OEChargeParameter(*args))
    __swig_destroy__ = _oequacpac.delete_OEChargeParameter

    def CreateCopy(self) -> "OESystem::OEParameter *":
        r"""CreateCopy(OEChargeParameter self) -> OEParameter"""
        return _oequacpac.OEChargeParameter_CreateCopy(self)

# Register OEChargeParameter in _oequacpac:
_oequacpac.OEChargeParameter_swigregister(OEChargeParameter)

class OEChargeEngineNoOp(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEChargeEngineNoOp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(OEChargeEngineNoOp self) -> OEChargeEngineNoOp"""
        _oequacpac.OEChargeEngineNoOp_swiginit(self, _oequacpac.new_OEChargeEngineNoOp())
    __swig_destroy__ = _oequacpac.delete_OEChargeEngineNoOp

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEChargeEngineNoOp self) -> OEChargeEngineBase"""
        return _oequacpac.OEChargeEngineNoOp_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEChargeEngineNoOp self) -> unsigned int"""
        return _oequacpac.OEChargeEngineNoOp_GetChargeType(self)

    def IsValid(self, mol: "OEMolBase") -> "bool":
        r"""IsValid(OEChargeEngineNoOp self, OEMolBase mol) -> bool"""
        return _oequacpac.OEChargeEngineNoOp_IsValid(self, mol)

    def CheckCharges(self, mol: "OEMolBase") -> "bool":
        r"""CheckCharges(OEChargeEngineNoOp self, OEMolBase mol) -> bool"""
        return _oequacpac.OEChargeEngineNoOp_CheckCharges(self, mol)

# Register OEChargeEngineNoOp in _oequacpac:
_oequacpac.OEChargeEngineNoOp_swigregister(OEChargeEngineNoOp)

class OEClearCharges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEClearCharges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(OEClearCharges self) -> OEClearCharges"""
        _oequacpac.OEClearCharges_swiginit(self, _oequacpac.new_OEClearCharges())
    __swig_destroy__ = _oequacpac.delete_OEClearCharges

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEClearCharges self) -> OEChargeEngineBase"""
        return _oequacpac.OEClearCharges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEClearCharges self) -> unsigned int"""
        return _oequacpac.OEClearCharges_GetChargeType(self)

    def IsValid(self, mol: "OEMolBase") -> "bool":
        r"""IsValid(OEClearCharges self, OEMolBase mol) -> bool"""
        return _oequacpac.OEClearCharges_IsValid(self, mol)

    def CheckCharges(self, mol: "OEMolBase") -> "bool":
        r"""CheckCharges(OEClearCharges self, OEMolBase mol) -> bool"""
        return _oequacpac.OEClearCharges_CheckCharges(self, mol)

# Register OEClearCharges in _oequacpac:
_oequacpac.OEClearCharges_swigregister(OEClearCharges)

class OEFormalToPartialCharges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEFormalToPartialCharges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(OEFormalToPartialCharges self) -> OEFormalToPartialCharges"""
        _oequacpac.OEFormalToPartialCharges_swiginit(self, _oequacpac.new_OEFormalToPartialCharges())
    __swig_destroy__ = _oequacpac.delete_OEFormalToPartialCharges

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEFormalToPartialCharges self) -> OEChargeEngineBase"""
        return _oequacpac.OEFormalToPartialCharges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEFormalToPartialCharges self) -> unsigned int"""
        return _oequacpac.OEFormalToPartialCharges_GetChargeType(self)

    def IsValid(self, mol: "OEMolBase") -> "bool":
        r"""IsValid(OEFormalToPartialCharges self, OEMolBase mol) -> bool"""
        return _oequacpac.OEFormalToPartialCharges_IsValid(self, mol)

# Register OEFormalToPartialCharges in _oequacpac:
_oequacpac.OEFormalToPartialCharges_swigregister(OEFormalToPartialCharges)

class OEInitialCharges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEInitialCharges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(OEInitialCharges self) -> OEInitialCharges"""
        _oequacpac.OEInitialCharges_swiginit(self, _oequacpac.new_OEInitialCharges())
    __swig_destroy__ = _oequacpac.delete_OEInitialCharges

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEInitialCharges self) -> OEChargeEngineBase"""
        return _oequacpac.OEInitialCharges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEInitialCharges self) -> unsigned int"""
        return _oequacpac.OEInitialCharges_GetChargeType(self)

    def IsValid(self, mol: "OEMolBase") -> "bool":
        r"""IsValid(OEInitialCharges self, OEMolBase mol) -> bool"""
        return _oequacpac.OEInitialCharges_IsValid(self, mol)

# Register OEInitialCharges in _oequacpac:
_oequacpac.OEInitialCharges_swigregister(OEInitialCharges)

class OEGasteigerCharges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEGasteigerCharges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(OEGasteigerCharges self) -> OEGasteigerCharges"""
        _oequacpac.OEGasteigerCharges_swiginit(self, _oequacpac.new_OEGasteigerCharges())
    __swig_destroy__ = _oequacpac.delete_OEGasteigerCharges

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEGasteigerCharges self) -> OEChargeEngineBase"""
        return _oequacpac.OEGasteigerCharges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEGasteigerCharges self) -> unsigned int"""
        return _oequacpac.OEGasteigerCharges_GetChargeType(self)

    def IsValid(self, mol: "OEMolBase") -> "bool":
        r"""IsValid(OEGasteigerCharges self, OEMolBase mol) -> bool"""
        return _oequacpac.OEGasteigerCharges_IsValid(self, mol)

# Register OEGasteigerCharges in _oequacpac:
_oequacpac.OEGasteigerCharges_swigregister(OEGasteigerCharges)

class OEMMFF94Charges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEMMFF94Charges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(OEMMFF94Charges self) -> OEMMFF94Charges"""
        _oequacpac.OEMMFF94Charges_swiginit(self, _oequacpac.new_OEMMFF94Charges())
    __swig_destroy__ = _oequacpac.delete_OEMMFF94Charges

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEMMFF94Charges self) -> OEChargeEngineBase"""
        return _oequacpac.OEMMFF94Charges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEMMFF94Charges self) -> unsigned int"""
        return _oequacpac.OEMMFF94Charges_GetChargeType(self)

    def IsValid(self, mol: "OEMolBase") -> "bool":
        r"""IsValid(OEMMFF94Charges self, OEMolBase mol) -> bool"""
        return _oequacpac.OEMMFF94Charges_IsValid(self, mol)

# Register OEMMFF94Charges in _oequacpac:
_oequacpac.OEMMFF94Charges_swigregister(OEMMFF94Charges)

class OEAM1Charges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEAM1Charges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, optimize: "bool"=True, symmetrize: "bool"=False, maxAtoms: "unsigned int"=300):
        r"""__init__(OEAM1Charges self, bool optimize=True, bool symmetrize=False, unsigned int maxAtoms=300) -> OEAM1Charges"""
        _oequacpac.OEAM1Charges_swiginit(self, _oequacpac.new_OEAM1Charges(optimize, symmetrize, maxAtoms))
    __swig_destroy__ = _oequacpac.delete_OEAM1Charges

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEAM1Charges self) -> OEChargeEngineBase"""
        return _oequacpac.OEAM1Charges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEAM1Charges self) -> unsigned int"""
        return _oequacpac.OEAM1Charges_GetChargeType(self)

    def GetOptimize(self) -> "bool":
        r"""GetOptimize(OEAM1Charges self) -> bool"""
        return _oequacpac.OEAM1Charges_GetOptimize(self)

    def GetSymmetrize(self) -> "bool":
        r"""GetSymmetrize(OEAM1Charges self) -> bool"""
        return _oequacpac.OEAM1Charges_GetSymmetrize(self)

    def GetSizeLimit(self) -> "unsigned int":
        r"""GetSizeLimit(OEAM1Charges self) -> unsigned int"""
        return _oequacpac.OEAM1Charges_GetSizeLimit(self)

    def SetOptimize(self, optimize: "bool"=True) -> "void":
        r"""SetOptimize(OEAM1Charges self, bool optimize=True)"""
        return _oequacpac.OEAM1Charges_SetOptimize(self, optimize)

    def SetSymmetrize(self, symmetrize: "bool"=True) -> "void":
        r"""SetSymmetrize(OEAM1Charges self, bool symmetrize=True)"""
        return _oequacpac.OEAM1Charges_SetSymmetrize(self, symmetrize)

    def SetSizeLimit(self, maxAtoms: "unsigned int") -> "void":
        r"""SetSizeLimit(OEAM1Charges self, unsigned int maxAtoms)"""
        return _oequacpac.OEAM1Charges_SetSizeLimit(self, maxAtoms)

    def IsValid(self, mol: "OEMolBase") -> "bool":
        r"""IsValid(OEAM1Charges self, OEMolBase mol) -> bool"""
        return _oequacpac.OEAM1Charges_IsValid(self, mol)

# Register OEAM1Charges in _oequacpac:
_oequacpac.OEAM1Charges_swigregister(OEAM1Charges)

class OEAM1BCCCharges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEAM1BCCCharges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, optimize: "bool"=True, symmetrize: "bool"=True, permissiveBCCs: "bool"=False, maxAtoms: "unsigned int"=300):
        r"""__init__(OEAM1BCCCharges self, bool optimize=True, bool symmetrize=True, bool permissiveBCCs=False, unsigned int maxAtoms=300) -> OEAM1BCCCharges"""
        _oequacpac.OEAM1BCCCharges_swiginit(self, _oequacpac.new_OEAM1BCCCharges(optimize, symmetrize, permissiveBCCs, maxAtoms))
    __swig_destroy__ = _oequacpac.delete_OEAM1BCCCharges

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEAM1BCCCharges self) -> OEChargeEngineBase"""
        return _oequacpac.OEAM1BCCCharges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEAM1BCCCharges self) -> unsigned int"""
        return _oequacpac.OEAM1BCCCharges_GetChargeType(self)

    def GetOptimize(self) -> "bool":
        r"""GetOptimize(OEAM1BCCCharges self) -> bool"""
        return _oequacpac.OEAM1BCCCharges_GetOptimize(self)

    def GetSymmetrize(self) -> "bool":
        r"""GetSymmetrize(OEAM1BCCCharges self) -> bool"""
        return _oequacpac.OEAM1BCCCharges_GetSymmetrize(self)

    def GetPermissiveBCCs(self) -> "bool":
        r"""GetPermissiveBCCs(OEAM1BCCCharges self) -> bool"""
        return _oequacpac.OEAM1BCCCharges_GetPermissiveBCCs(self)

    def GetSizeLimit(self) -> "unsigned int":
        r"""GetSizeLimit(OEAM1BCCCharges self) -> unsigned int"""
        return _oequacpac.OEAM1BCCCharges_GetSizeLimit(self)

    def SetOptimize(self, optimize: "bool"=True) -> "void":
        r"""SetOptimize(OEAM1BCCCharges self, bool optimize=True)"""
        return _oequacpac.OEAM1BCCCharges_SetOptimize(self, optimize)

    def SetSymmetrize(self, symmetrize: "bool"=True) -> "void":
        r"""SetSymmetrize(OEAM1BCCCharges self, bool symmetrize=True)"""
        return _oequacpac.OEAM1BCCCharges_SetSymmetrize(self, symmetrize)

    def SetPermissiveBCCs(self, permissive: "bool"=True) -> "void":
        r"""SetPermissiveBCCs(OEAM1BCCCharges self, bool permissive=True)"""
        return _oequacpac.OEAM1BCCCharges_SetPermissiveBCCs(self, permissive)

    def SetSizeLimit(self, maxAtoms: "unsigned int") -> "void":
        r"""SetSizeLimit(OEAM1BCCCharges self, unsigned int maxAtoms)"""
        return _oequacpac.OEAM1BCCCharges_SetSizeLimit(self, maxAtoms)

    def IsValid(self, *args) -> "bool":
        r"""
        IsValid(OEAM1BCCCharges self, OEMolBase mol) -> bool
        IsValid(OEAM1BCCCharges self, OEMCMolBase mcMol) -> bool
        """
        return _oequacpac.OEAM1BCCCharges_IsValid(self, *args)

# Register OEAM1BCCCharges in _oequacpac:
_oequacpac.OEAM1BCCCharges_swigregister(OEAM1BCCCharges)

class OEAmberFF94Charges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEAmberFF94Charges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(OEAmberFF94Charges self) -> OEAmberFF94Charges"""
        _oequacpac.OEAmberFF94Charges_swiginit(self, _oequacpac.new_OEAmberFF94Charges())
    __swig_destroy__ = _oequacpac.delete_OEAmberFF94Charges

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEAmberFF94Charges self) -> OEChargeEngineBase"""
        return _oequacpac.OEAmberFF94Charges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEAmberFF94Charges self) -> unsigned int"""
        return _oequacpac.OEAmberFF94Charges_GetChargeType(self)

    def IsValid(self, mol: "OEMolBase") -> "bool":
        r"""IsValid(OEAmberFF94Charges self, OEMolBase mol) -> bool"""
        return _oequacpac.OEAmberFF94Charges_IsValid(self, mol)

# Register OEAmberFF94Charges in _oequacpac:
_oequacpac.OEAmberFF94Charges_swigregister(OEAmberFF94Charges)

class OECombineChargeEngines(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OECombineChargeEngines class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OECombineChargeEngines

    def __init__(self, *args):
        r"""
        __init__(OECombineChargeEngines self, OEChargeEngineBase preChargeEngine, OEChargeEngineBase adjustmentEngine) -> OECombineChargeEngines
        __init__(OECombineChargeEngines self, OECombineChargeEngines rhs) -> OECombineChargeEngines
        """
        _oequacpac.OECombineChargeEngines_swiginit(self, _oequacpac.new_OECombineChargeEngines(*args))

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OECombineChargeEngines self) -> OEChargeEngineBase"""
        return _oequacpac.OECombineChargeEngines_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OECombineChargeEngines self) -> unsigned int"""
        return _oequacpac.OECombineChargeEngines_GetChargeType(self)

    def IsValid(self, *args) -> "bool":
        r"""
        IsValid(OECombineChargeEngines self, OEMolBase mol) -> bool
        IsValid(OECombineChargeEngines self, OEMCMolBase mcMol) -> bool
        """
        return _oequacpac.OECombineChargeEngines_IsValid(self, *args)

    def CheckCharges(self, *args) -> "bool":
        r"""
        CheckCharges(OECombineChargeEngines self, OEMolBase mol) -> bool
        CheckCharges(OECombineChargeEngines self, OEMCMolBase mcMol) -> bool
        """
        return _oequacpac.OECombineChargeEngines_CheckCharges(self, *args)

    def TransferCharge(self, dstAtom: "OEAtomBase", srcAtom: "OEAtomBase") -> "bool":
        r"""TransferCharge(OECombineChargeEngines self, OEAtomBase dstAtom, OEAtomBase srcAtom) -> bool"""
        return _oequacpac.OECombineChargeEngines_TransferCharge(self, dstAtom, srcAtom)

# Register OECombineChargeEngines in _oequacpac:
_oequacpac.OECombineChargeEngines_swigregister(OECombineChargeEngines)

class OEELFCharges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEELFCharges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEELFCharges

    def __init__(self, *args):
        r"""
        __init__(OEELFCharges self, OEChargeEngineBase chargeEngine, unsigned int limit=10, double percentage=2.0, bool selectedConfs=False) -> OEELFCharges
        __init__(OEELFCharges self, OEELFCharges rhs) -> OEELFCharges
        """
        _oequacpac.OEELFCharges_swiginit(self, _oequacpac.new_OEELFCharges(*args))

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEELFCharges self) -> OEChargeEngineBase"""
        return _oequacpac.OEELFCharges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEELFCharges self) -> unsigned int"""
        return _oequacpac.OEELFCharges_GetChargeType(self)

    def GetLimit(self) -> "unsigned int":
        r"""GetLimit(OEELFCharges self) -> unsigned int"""
        return _oequacpac.OEELFCharges_GetLimit(self)

    def GetPercentage(self) -> "double":
        r"""GetPercentage(OEELFCharges self) -> double"""
        return _oequacpac.OEELFCharges_GetPercentage(self)

    def GetReturnSelectedConfs(self) -> "bool":
        r"""GetReturnSelectedConfs(OEELFCharges self) -> bool"""
        return _oequacpac.OEELFCharges_GetReturnSelectedConfs(self)

    def SetLimit(self, limit: "unsigned int") -> "void":
        r"""SetLimit(OEELFCharges self, unsigned int limit)"""
        return _oequacpac.OEELFCharges_SetLimit(self, limit)

    def SetPercentage(self, pct: "double") -> "void":
        r"""SetPercentage(OEELFCharges self, double pct)"""
        return _oequacpac.OEELFCharges_SetPercentage(self, pct)

    def SetReturnSelectedConfs(self, selected: "bool"=True) -> "void":
        r"""SetReturnSelectedConfs(OEELFCharges self, bool selected=True)"""
        return _oequacpac.OEELFCharges_SetReturnSelectedConfs(self, selected)

    def IsValid(self, *args) -> "bool":
        r"""
        IsValid(OEELFCharges self, OEMolBase mol) -> bool
        IsValid(OEELFCharges self, OEMCMolBase mcMol) -> bool
        """
        return _oequacpac.OEELFCharges_IsValid(self, *args)

    def CheckCharges(self, *args) -> "bool":
        r"""
        CheckCharges(OEELFCharges self, OEMolBase mol) -> bool
        CheckCharges(OEELFCharges self, OEMCMolBase mcMol) -> bool
        """
        return _oequacpac.OEELFCharges_CheckCharges(self, *args)

    def TransferCharge(self, dstAtom: "OEAtomBase", srcAtom: "OEAtomBase") -> "bool":
        r"""TransferCharge(OEELFCharges self, OEAtomBase dstAtom, OEAtomBase srcAtom) -> bool"""
        return _oequacpac.OEELFCharges_TransferCharge(self, dstAtom, srcAtom)

# Register OEELFCharges in _oequacpac:
_oequacpac.OEELFCharges_swigregister(OEELFCharges)

class OEAM1BCCELF10Charges(OEELFCharges):
    r"""Proxy of C++ OEProton::OEAM1BCCELF10Charges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEAM1BCCELF10Charges

    def __init__(self, *args):
        r"""
        __init__(OEAM1BCCELF10Charges self) -> OEAM1BCCELF10Charges
        __init__(OEAM1BCCELF10Charges self, OEAM1BCCELF10Charges rhs) -> OEAM1BCCELF10Charges
        """
        _oequacpac.OEAM1BCCELF10Charges_swiginit(self, _oequacpac.new_OEAM1BCCELF10Charges(*args))

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEAM1BCCELF10Charges self) -> OEChargeEngineBase"""
        return _oequacpac.OEAM1BCCELF10Charges_CreateCopy(self)

# Register OEAM1BCCELF10Charges in _oequacpac:
_oequacpac.OEAM1BCCELF10Charges_swigregister(OEAM1BCCELF10Charges)

class OESpreadMetalCharges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OESpreadMetalCharges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, chargeAliquot: "double"=0.25, radiusMargin: "double"=0.25, maxNbrDist: "double"=6.0):
        r"""__init__(OESpreadMetalCharges self, double chargeAliquot=0.25, double radiusMargin=0.25, double maxNbrDist=6.0) -> OESpreadMetalCharges"""
        _oequacpac.OESpreadMetalCharges_swiginit(self, _oequacpac.new_OESpreadMetalCharges(chargeAliquot, radiusMargin, maxNbrDist))
    __swig_destroy__ = _oequacpac.delete_OESpreadMetalCharges

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OESpreadMetalCharges self) -> OEChargeEngineBase"""
        return _oequacpac.OESpreadMetalCharges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OESpreadMetalCharges self) -> unsigned int"""
        return _oequacpac.OESpreadMetalCharges_GetChargeType(self)

    def GetChargeAliquot(self) -> "double":
        r"""GetChargeAliquot(OESpreadMetalCharges self) -> double"""
        return _oequacpac.OESpreadMetalCharges_GetChargeAliquot(self)

    def GetMaxNbrDist(self) -> "double":
        r"""GetMaxNbrDist(OESpreadMetalCharges self) -> double"""
        return _oequacpac.OESpreadMetalCharges_GetMaxNbrDist(self)

    def GetRadiusMargin(self) -> "double":
        r"""GetRadiusMargin(OESpreadMetalCharges self) -> double"""
        return _oequacpac.OESpreadMetalCharges_GetRadiusMargin(self)

    def SetChargeAliquot(self, aliquot: "double") -> "void":
        r"""SetChargeAliquot(OESpreadMetalCharges self, double aliquot)"""
        return _oequacpac.OESpreadMetalCharges_SetChargeAliquot(self, aliquot)

    def SetMaxNbrDist(self, distance: "double") -> "void":
        r"""SetMaxNbrDist(OESpreadMetalCharges self, double distance)"""
        return _oequacpac.OESpreadMetalCharges_SetMaxNbrDist(self, distance)

    def SetRadiusMargin(self, distance: "double") -> "void":
        r"""SetRadiusMargin(OESpreadMetalCharges self, double distance)"""
        return _oequacpac.OESpreadMetalCharges_SetRadiusMargin(self, distance)

    def IsValid(self, mol: "OEMolBase") -> "bool":
        r"""IsValid(OESpreadMetalCharges self, OEMolBase mol) -> bool"""
        return _oequacpac.OESpreadMetalCharges_IsValid(self, mol)

# Register OESpreadMetalCharges in _oequacpac:
_oequacpac.OESpreadMetalCharges_swigregister(OESpreadMetalCharges)

class OEDesignUnitCharges(OEChargeEngineBase):
    r"""Proxy of C++ OEProton::OEDesignUnitCharges class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _oequacpac.delete_OEDesignUnitCharges

    def __init__(self, *args):
        r"""
        __init__(OEDesignUnitCharges self) -> OEDesignUnitCharges
        __init__(OEDesignUnitCharges self, OEDesignUnitCharges rhs) -> OEDesignUnitCharges
        """
        _oequacpac.OEDesignUnitCharges_swiginit(self, _oequacpac.new_OEDesignUnitCharges(*args))

    def CreateCopy(self) -> "OEProton::OEChargeEngineBase *":
        r"""CreateCopy(OEDesignUnitCharges self) -> OEChargeEngineBase"""
        return _oequacpac.OEDesignUnitCharges_CreateCopy(self)

    def GetChargeType(self) -> "unsigned int":
        r"""GetChargeType(OEDesignUnitCharges self) -> unsigned int"""
        return _oequacpac.OEDesignUnitCharges_GetChargeType(self)

    def SetFallbackChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetFallbackChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetFallbackChargeEngine(self, chargeEngine)

    def SetProteinChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetProteinChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetProteinChargeEngine(self, chargeEngine)

    def SetProteinNonStandardChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetProteinNonStandardChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetProteinNonStandardChargeEngine(self, chargeEngine)

    def SetNucleicChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetNucleicChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetNucleicChargeEngine(self, chargeEngine)

    def SetLigandChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetLigandChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetLigandChargeEngine(self, chargeEngine)

    def SetCoFactorChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetCoFactorChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetCoFactorChargeEngine(self, chargeEngine)

    def SetSolventChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetSolventChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetSolventChargeEngine(self, chargeEngine)

    def SetMetalChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetMetalChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetMetalChargeEngine(self, chargeEngine)

    def SetOtherChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetOtherChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetOtherChargeEngine(self, chargeEngine)

    def SetFinalizationChargeEngine(self, chargeEngine: "OEChargeEngineBase") -> "void":
        r"""SetFinalizationChargeEngine(OEDesignUnitCharges self, OEChargeEngineBase chargeEngine)"""
        return _oequacpac.OEDesignUnitCharges_SetFinalizationChargeEngine(self, chargeEngine)

    def UseSZMAPWaterModel(self, value: "bool const") -> "void":
        r"""UseSZMAPWaterModel(OEDesignUnitCharges self, bool const value)"""
        return _oequacpac.OEDesignUnitCharges_UseSZMAPWaterModel(self, value)

    def IsValid(self, *args) -> "bool":
        r"""
        IsValid(OEDesignUnitCharges self, OEMolBase mol) -> bool
        IsValid(OEDesignUnitCharges self, OEDesignUnit du) -> bool
        """
        return _oequacpac.OEDesignUnitCharges_IsValid(self, *args)

    def ApplyCharges(self, du: "OEDesignUnit") -> "bool":
        r"""ApplyCharges(OEDesignUnitCharges self, OEDesignUnit du) -> bool"""
        return _oequacpac.OEDesignUnitCharges_ApplyCharges(self, du)

    def TransferCharge(self, dstAtom: "OEAtomBase", srcAtom: "OEAtomBase") -> "bool":
        r"""TransferCharge(OEDesignUnitCharges self, OEAtomBase dstAtom, OEAtomBase srcAtom) -> bool"""
        return _oequacpac.OEDesignUnitCharges_TransferCharge(self, dstAtom, srcAtom)

# Register OEDesignUnitCharges in _oequacpac:
_oequacpac.OEDesignUnitCharges_swigregister(OEDesignUnitCharges)


def OEAssignCharges(*args) -> "bool":
    r"""
    OEAssignCharges(OEMolBase mol, OEChargeEngineBase chargeEngine) -> bool
    OEAssignCharges(OEMCMolBase mcMol, OEChargeEngineBase chargeEngine) -> bool
    """
    return _oequacpac.OEAssignCharges(*args)


