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

"""
Transfer module, see official documentation at
https://www.opencascade.com/doc/occt-7.4.0/refman/html/package_transfer.html
"""

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

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _Transfer
else:
    import _Transfer

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


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

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

    def value(self) -> "PyObject *":
        return _Transfer.SwigPyIterator_value(self)

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

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

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

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

    def copy(self) -> "swig::SwigPyIterator *":
        return _Transfer.SwigPyIterator_copy(self)

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

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

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

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

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

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

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _Transfer.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _Transfer.SwigPyIterator___isub__(self, n)

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

    def __sub__(self, *args) -> "ptrdiff_t":
        return _Transfer.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _Transfer:
_Transfer.SwigPyIterator_swigregister(SwigPyIterator)


def _dumps_object(klass):
    """ Overwrite default string output for any wrapped object.
    By default, __repr__ method returns something like:
    <OCC.Core.TopoDS.TopoDS_Shape; proxy of <Swig Object of type 'TopoDS_Shape *' at 0x02BB0758> >
    This is too much verbose.
    We prefer :
    <class 'gp_Pnt'>
    or
    <class 'TopoDS_Shape'>
    """
    klass_name = str(klass.__class__).split(".")[3].split("'")[0]
    repr_string = "<class '" + klass_name + "'"
# for TopoDS_Shape, we also look for the base type
    if klass_name == "TopoDS_Shape":
        if klass.IsNull():
            repr_string += ": Null>"
            return repr_string
        st = klass.ShapeType()
        types = {OCC.Core.TopAbs.TopAbs_VERTEX: "Vertex",
                 OCC.Core.TopAbs.TopAbs_SOLID: "Solid",
                 OCC.Core.TopAbs.TopAbs_EDGE: "Edge",
                 OCC.Core.TopAbs.TopAbs_FACE: "Face",
                 OCC.Core.TopAbs.TopAbs_SHELL: "Shell",
                 OCC.Core.TopAbs.TopAbs_WIRE: "Wire",
                 OCC.Core.TopAbs.TopAbs_COMPOUND: "Compound",
                 OCC.Core.TopAbs.TopAbs_COMPSOLID: "Compsolid"}
        repr_string += "; Type:%s" % types[st]        
    elif hasattr(klass, "IsNull"):
        if klass.IsNull():
            repr_string += "; Null"
    repr_string += ">"
    return repr_string


def process_exception(error: "Standard_Failure", method_name: "std::string", class_name: "std::string") -> "void":
    return _Transfer.process_exception(error, method_name, class_name)

from six import with_metaclass
import warnings
from OCC.Wrapper.wrapper_utils import Proxy, deprecated

import OCC.Core.Standard
import OCC.Core.NCollection
import OCC.Core.Message
import OCC.Core.TCollection
import OCC.Core.OSD
import OCC.Core.TColStd
import OCC.Core.Interface
import OCC.Core.MoniTool
import OCC.Core.TopoDS
import OCC.Core.TopAbs
import OCC.Core.TopLoc
import OCC.Core.gp

from enum import IntEnum
from OCC.Core.Exception import *

Transfer_StatusInitial = _Transfer.Transfer_StatusInitial
Transfer_StatusRun = _Transfer.Transfer_StatusRun
Transfer_StatusDone = _Transfer.Transfer_StatusDone
Transfer_StatusError = _Transfer.Transfer_StatusError
Transfer_StatusLoop = _Transfer.Transfer_StatusLoop
Transfer_UndefIgnore = _Transfer.Transfer_UndefIgnore
Transfer_UndefFailure = _Transfer.Transfer_UndefFailure
Transfer_UndefContent = _Transfer.Transfer_UndefContent
Transfer_UndefUser = _Transfer.Transfer_UndefUser
Transfer_StatusVoid = _Transfer.Transfer_StatusVoid
Transfer_StatusDefined = _Transfer.Transfer_StatusDefined
Transfer_StatusUsed = _Transfer.Transfer_StatusUsed


class Transfer_StatusExec(IntEnum):
	Transfer_StatusInitial = 0
	Transfer_StatusRun = 1
	Transfer_StatusDone = 2
	Transfer_StatusError = 3
	Transfer_StatusLoop = 4
Transfer_StatusInitial = Transfer_StatusExec.Transfer_StatusInitial
Transfer_StatusRun = Transfer_StatusExec.Transfer_StatusRun
Transfer_StatusDone = Transfer_StatusExec.Transfer_StatusDone
Transfer_StatusError = Transfer_StatusExec.Transfer_StatusError
Transfer_StatusLoop = Transfer_StatusExec.Transfer_StatusLoop

class Transfer_UndefMode(IntEnum):
	Transfer_UndefIgnore = 0
	Transfer_UndefFailure = 1
	Transfer_UndefContent = 2
	Transfer_UndefUser = 3
Transfer_UndefIgnore = Transfer_UndefMode.Transfer_UndefIgnore
Transfer_UndefFailure = Transfer_UndefMode.Transfer_UndefFailure
Transfer_UndefContent = Transfer_UndefMode.Transfer_UndefContent
Transfer_UndefUser = Transfer_UndefMode.Transfer_UndefUser

class Transfer_StatusResult(IntEnum):
	Transfer_StatusVoid = 0
	Transfer_StatusDefined = 1
	Transfer_StatusUsed = 2
Transfer_StatusVoid = Transfer_StatusResult.Transfer_StatusVoid
Transfer_StatusDefined = Transfer_StatusResult.Transfer_StatusDefined
Transfer_StatusUsed = Transfer_StatusResult.Transfer_StatusUsed


def Handle_Transfer_ActorOfProcessForFinder_Create() -> "opencascade::handle< Transfer_ActorOfProcessForFinder >":
    return _Transfer.Handle_Transfer_ActorOfProcessForFinder_Create()

def Handle_Transfer_ActorOfProcessForFinder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_ActorOfProcessForFinder >":
    return _Transfer.Handle_Transfer_ActorOfProcessForFinder_DownCast(t)

def Handle_Transfer_ActorOfProcessForFinder_IsNull(t: "opencascade::handle< Transfer_ActorOfProcessForFinder > const &") -> "bool":
    return _Transfer.Handle_Transfer_ActorOfProcessForFinder_IsNull(t)

def Handle_Transfer_ActorOfProcessForTransient_Create() -> "opencascade::handle< Transfer_ActorOfProcessForTransient >":
    return _Transfer.Handle_Transfer_ActorOfProcessForTransient_Create()

def Handle_Transfer_ActorOfProcessForTransient_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_ActorOfProcessForTransient >":
    return _Transfer.Handle_Transfer_ActorOfProcessForTransient_DownCast(t)

def Handle_Transfer_ActorOfProcessForTransient_IsNull(t: "opencascade::handle< Transfer_ActorOfProcessForTransient > const &") -> "bool":
    return _Transfer.Handle_Transfer_ActorOfProcessForTransient_IsNull(t)

def Handle_Transfer_Binder_Create() -> "opencascade::handle< Transfer_Binder >":
    return _Transfer.Handle_Transfer_Binder_Create()

def Handle_Transfer_Binder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_Binder >":
    return _Transfer.Handle_Transfer_Binder_DownCast(t)

def Handle_Transfer_Binder_IsNull(t: "opencascade::handle< Transfer_Binder > const &") -> "bool":
    return _Transfer.Handle_Transfer_Binder_IsNull(t)

def Handle_Transfer_DispatchControl_Create() -> "opencascade::handle< Transfer_DispatchControl >":
    return _Transfer.Handle_Transfer_DispatchControl_Create()

def Handle_Transfer_DispatchControl_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_DispatchControl >":
    return _Transfer.Handle_Transfer_DispatchControl_DownCast(t)

def Handle_Transfer_DispatchControl_IsNull(t: "opencascade::handle< Transfer_DispatchControl > const &") -> "bool":
    return _Transfer.Handle_Transfer_DispatchControl_IsNull(t)

def Handle_Transfer_Finder_Create() -> "opencascade::handle< Transfer_Finder >":
    return _Transfer.Handle_Transfer_Finder_Create()

def Handle_Transfer_Finder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_Finder >":
    return _Transfer.Handle_Transfer_Finder_DownCast(t)

def Handle_Transfer_Finder_IsNull(t: "opencascade::handle< Transfer_Finder > const &") -> "bool":
    return _Transfer.Handle_Transfer_Finder_IsNull(t)

def Handle_Transfer_MapContainer_Create() -> "opencascade::handle< Transfer_MapContainer >":
    return _Transfer.Handle_Transfer_MapContainer_Create()

def Handle_Transfer_MapContainer_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_MapContainer >":
    return _Transfer.Handle_Transfer_MapContainer_DownCast(t)

def Handle_Transfer_MapContainer_IsNull(t: "opencascade::handle< Transfer_MapContainer > const &") -> "bool":
    return _Transfer.Handle_Transfer_MapContainer_IsNull(t)

def Handle_Transfer_ProcessForTransient_Create() -> "opencascade::handle< Transfer_ProcessForTransient >":
    return _Transfer.Handle_Transfer_ProcessForTransient_Create()

def Handle_Transfer_ProcessForTransient_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_ProcessForTransient >":
    return _Transfer.Handle_Transfer_ProcessForTransient_DownCast(t)

def Handle_Transfer_ProcessForTransient_IsNull(t: "opencascade::handle< Transfer_ProcessForTransient > const &") -> "bool":
    return _Transfer.Handle_Transfer_ProcessForTransient_IsNull(t)

def Handle_Transfer_ResultFromModel_Create() -> "opencascade::handle< Transfer_ResultFromModel >":
    return _Transfer.Handle_Transfer_ResultFromModel_Create()

def Handle_Transfer_ResultFromModel_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_ResultFromModel >":
    return _Transfer.Handle_Transfer_ResultFromModel_DownCast(t)

def Handle_Transfer_ResultFromModel_IsNull(t: "opencascade::handle< Transfer_ResultFromModel > const &") -> "bool":
    return _Transfer.Handle_Transfer_ResultFromModel_IsNull(t)

def Handle_Transfer_ResultFromTransient_Create() -> "opencascade::handle< Transfer_ResultFromTransient >":
    return _Transfer.Handle_Transfer_ResultFromTransient_Create()

def Handle_Transfer_ResultFromTransient_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_ResultFromTransient >":
    return _Transfer.Handle_Transfer_ResultFromTransient_DownCast(t)

def Handle_Transfer_ResultFromTransient_IsNull(t: "opencascade::handle< Transfer_ResultFromTransient > const &") -> "bool":
    return _Transfer.Handle_Transfer_ResultFromTransient_IsNull(t)

def Handle_Transfer_ActorOfFinderProcess_Create() -> "opencascade::handle< Transfer_ActorOfFinderProcess >":
    return _Transfer.Handle_Transfer_ActorOfFinderProcess_Create()

def Handle_Transfer_ActorOfFinderProcess_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_ActorOfFinderProcess >":
    return _Transfer.Handle_Transfer_ActorOfFinderProcess_DownCast(t)

def Handle_Transfer_ActorOfFinderProcess_IsNull(t: "opencascade::handle< Transfer_ActorOfFinderProcess > const &") -> "bool":
    return _Transfer.Handle_Transfer_ActorOfFinderProcess_IsNull(t)

def Handle_Transfer_ActorOfTransientProcess_Create() -> "opencascade::handle< Transfer_ActorOfTransientProcess >":
    return _Transfer.Handle_Transfer_ActorOfTransientProcess_Create()

def Handle_Transfer_ActorOfTransientProcess_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_ActorOfTransientProcess >":
    return _Transfer.Handle_Transfer_ActorOfTransientProcess_DownCast(t)

def Handle_Transfer_ActorOfTransientProcess_IsNull(t: "opencascade::handle< Transfer_ActorOfTransientProcess > const &") -> "bool":
    return _Transfer.Handle_Transfer_ActorOfTransientProcess_IsNull(t)

def Handle_Transfer_FinderProcess_Create() -> "opencascade::handle< Transfer_FinderProcess >":
    return _Transfer.Handle_Transfer_FinderProcess_Create()

def Handle_Transfer_FinderProcess_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_FinderProcess >":
    return _Transfer.Handle_Transfer_FinderProcess_DownCast(t)

def Handle_Transfer_FinderProcess_IsNull(t: "opencascade::handle< Transfer_FinderProcess > const &") -> "bool":
    return _Transfer.Handle_Transfer_FinderProcess_IsNull(t)

def Handle_Transfer_MultipleBinder_Create() -> "opencascade::handle< Transfer_MultipleBinder >":
    return _Transfer.Handle_Transfer_MultipleBinder_Create()

def Handle_Transfer_MultipleBinder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_MultipleBinder >":
    return _Transfer.Handle_Transfer_MultipleBinder_DownCast(t)

def Handle_Transfer_MultipleBinder_IsNull(t: "opencascade::handle< Transfer_MultipleBinder > const &") -> "bool":
    return _Transfer.Handle_Transfer_MultipleBinder_IsNull(t)

def Handle_Transfer_SimpleBinderOfTransient_Create() -> "opencascade::handle< Transfer_SimpleBinderOfTransient >":
    return _Transfer.Handle_Transfer_SimpleBinderOfTransient_Create()

def Handle_Transfer_SimpleBinderOfTransient_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_SimpleBinderOfTransient >":
    return _Transfer.Handle_Transfer_SimpleBinderOfTransient_DownCast(t)

def Handle_Transfer_SimpleBinderOfTransient_IsNull(t: "opencascade::handle< Transfer_SimpleBinderOfTransient > const &") -> "bool":
    return _Transfer.Handle_Transfer_SimpleBinderOfTransient_IsNull(t)

def Handle_Transfer_TransientListBinder_Create() -> "opencascade::handle< Transfer_TransientListBinder >":
    return _Transfer.Handle_Transfer_TransientListBinder_Create()

def Handle_Transfer_TransientListBinder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_TransientListBinder >":
    return _Transfer.Handle_Transfer_TransientListBinder_DownCast(t)

def Handle_Transfer_TransientListBinder_IsNull(t: "opencascade::handle< Transfer_TransientListBinder > const &") -> "bool":
    return _Transfer.Handle_Transfer_TransientListBinder_IsNull(t)

def Handle_Transfer_TransientMapper_Create() -> "opencascade::handle< Transfer_TransientMapper >":
    return _Transfer.Handle_Transfer_TransientMapper_Create()

def Handle_Transfer_TransientMapper_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_TransientMapper >":
    return _Transfer.Handle_Transfer_TransientMapper_DownCast(t)

def Handle_Transfer_TransientMapper_IsNull(t: "opencascade::handle< Transfer_TransientMapper > const &") -> "bool":
    return _Transfer.Handle_Transfer_TransientMapper_IsNull(t)

def Handle_Transfer_TransientProcess_Create() -> "opencascade::handle< Transfer_TransientProcess >":
    return _Transfer.Handle_Transfer_TransientProcess_Create()

def Handle_Transfer_TransientProcess_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_TransientProcess >":
    return _Transfer.Handle_Transfer_TransientProcess_DownCast(t)

def Handle_Transfer_TransientProcess_IsNull(t: "opencascade::handle< Transfer_TransientProcess > const &") -> "bool":
    return _Transfer.Handle_Transfer_TransientProcess_IsNull(t)

def Handle_Transfer_VoidBinder_Create() -> "opencascade::handle< Transfer_VoidBinder >":
    return _Transfer.Handle_Transfer_VoidBinder_Create()

def Handle_Transfer_VoidBinder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_VoidBinder >":
    return _Transfer.Handle_Transfer_VoidBinder_DownCast(t)

def Handle_Transfer_VoidBinder_IsNull(t: "opencascade::handle< Transfer_VoidBinder > const &") -> "bool":
    return _Transfer.Handle_Transfer_VoidBinder_IsNull(t)

def Handle_Transfer_ActorDispatch_Create() -> "opencascade::handle< Transfer_ActorDispatch >":
    return _Transfer.Handle_Transfer_ActorDispatch_Create()

def Handle_Transfer_ActorDispatch_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_ActorDispatch >":
    return _Transfer.Handle_Transfer_ActorDispatch_DownCast(t)

def Handle_Transfer_ActorDispatch_IsNull(t: "opencascade::handle< Transfer_ActorDispatch > const &") -> "bool":
    return _Transfer.Handle_Transfer_ActorDispatch_IsNull(t)

def Handle_Transfer_BinderOfTransientInteger_Create() -> "opencascade::handle< Transfer_BinderOfTransientInteger >":
    return _Transfer.Handle_Transfer_BinderOfTransientInteger_Create()

def Handle_Transfer_BinderOfTransientInteger_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_BinderOfTransientInteger >":
    return _Transfer.Handle_Transfer_BinderOfTransientInteger_DownCast(t)

def Handle_Transfer_BinderOfTransientInteger_IsNull(t: "opencascade::handle< Transfer_BinderOfTransientInteger > const &") -> "bool":
    return _Transfer.Handle_Transfer_BinderOfTransientInteger_IsNull(t)

def Handle_Transfer_HSequenceOfBinder_Create() -> "opencascade::handle< Transfer_HSequenceOfBinder >":
    return _Transfer.Handle_Transfer_HSequenceOfBinder_Create()

def Handle_Transfer_HSequenceOfBinder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_HSequenceOfBinder >":
    return _Transfer.Handle_Transfer_HSequenceOfBinder_DownCast(t)

def Handle_Transfer_HSequenceOfBinder_IsNull(t: "opencascade::handle< Transfer_HSequenceOfBinder > const &") -> "bool":
    return _Transfer.Handle_Transfer_HSequenceOfBinder_IsNull(t)

def Handle_Transfer_HSequenceOfFinder_Create() -> "opencascade::handle< Transfer_HSequenceOfFinder >":
    return _Transfer.Handle_Transfer_HSequenceOfFinder_Create()

def Handle_Transfer_HSequenceOfFinder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_HSequenceOfFinder >":
    return _Transfer.Handle_Transfer_HSequenceOfFinder_DownCast(t)

def Handle_Transfer_HSequenceOfFinder_IsNull(t: "opencascade::handle< Transfer_HSequenceOfFinder > const &") -> "bool":
    return _Transfer.Handle_Transfer_HSequenceOfFinder_IsNull(t)
class Transfer_SequenceOfBinder(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self) -> "NCollection_Sequence< opencascade::handle< Transfer_Binder > >::iterator":
        return _Transfer.Transfer_SequenceOfBinder_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< Transfer_Binder > >::iterator":
        return _Transfer.Transfer_SequenceOfBinder_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< Transfer_Binder > >::const_iterator":
        return _Transfer.Transfer_SequenceOfBinder_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< Transfer_Binder > >::const_iterator":
        return _Transfer.Transfer_SequenceOfBinder_cend(self)

    def __init__(self, *args):
        _Transfer.Transfer_SequenceOfBinder_swiginit(self, _Transfer.new_Transfer_SequenceOfBinder(*args))

    def Size(self) -> "Standard_Integer":
        return _Transfer.Transfer_SequenceOfBinder_Size(self)

    def Length(self) -> "Standard_Integer":
        return _Transfer.Transfer_SequenceOfBinder_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _Transfer.Transfer_SequenceOfBinder_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _Transfer.Transfer_SequenceOfBinder_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _Transfer.Transfer_SequenceOfBinder_IsEmpty(self)

    def Reverse(self) -> "void":
        return _Transfer.Transfer_SequenceOfBinder_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _Transfer.Transfer_SequenceOfBinder_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
        return _Transfer.Transfer_SequenceOfBinder_delNode(theNode, theAl)

    def Clear(self, theAllocator: "opencascade::handle< NCollection_BaseAllocator > const &"=0) -> "void":
        return _Transfer.Transfer_SequenceOfBinder_Clear(self, theAllocator)

    def Assign(self, theOther: "Transfer_SequenceOfBinder") -> "NCollection_Sequence< opencascade::handle< Transfer_Binder > > &":
        return _Transfer.Transfer_SequenceOfBinder_Assign(self, theOther)

    def Set(self, theOther: "Transfer_SequenceOfBinder") -> "NCollection_Sequence< opencascade::handle< Transfer_Binder > > &":
        return _Transfer.Transfer_SequenceOfBinder_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfBinder_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfBinder_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfBinder_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfBinder_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfBinder_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "Transfer_SequenceOfBinder") -> "void":
        return _Transfer.Transfer_SequenceOfBinder_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< Transfer_Binder > const &":
        return _Transfer.Transfer_SequenceOfBinder_First(self)

    def ChangeFirst(self) -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_SequenceOfBinder_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< Transfer_Binder > const &":
        return _Transfer.Transfer_SequenceOfBinder_Last(self)

    def ChangeLast(self) -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_SequenceOfBinder_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Transfer_Binder > const &":
        return _Transfer.Transfer_SequenceOfBinder_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_SequenceOfBinder_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_SequenceOfBinder___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< Transfer_Binder > const &") -> "void":
        return _Transfer.Transfer_SequenceOfBinder_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _Transfer.delete_Transfer_SequenceOfBinder

    def __len__(self):
        return self.Size()


# Register Transfer_SequenceOfBinder in _Transfer:
_Transfer.Transfer_SequenceOfBinder_swigregister(Transfer_SequenceOfBinder)

def Transfer_SequenceOfBinder_delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
    return _Transfer.Transfer_SequenceOfBinder_delNode(theNode, theAl)

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

    def begin(self) -> "NCollection_Sequence< opencascade::handle< Transfer_Finder > >::iterator":
        return _Transfer.Transfer_SequenceOfFinder_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< Transfer_Finder > >::iterator":
        return _Transfer.Transfer_SequenceOfFinder_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< Transfer_Finder > >::const_iterator":
        return _Transfer.Transfer_SequenceOfFinder_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< Transfer_Finder > >::const_iterator":
        return _Transfer.Transfer_SequenceOfFinder_cend(self)

    def __init__(self, *args):
        _Transfer.Transfer_SequenceOfFinder_swiginit(self, _Transfer.new_Transfer_SequenceOfFinder(*args))

    def Size(self) -> "Standard_Integer":
        return _Transfer.Transfer_SequenceOfFinder_Size(self)

    def Length(self) -> "Standard_Integer":
        return _Transfer.Transfer_SequenceOfFinder_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _Transfer.Transfer_SequenceOfFinder_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _Transfer.Transfer_SequenceOfFinder_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _Transfer.Transfer_SequenceOfFinder_IsEmpty(self)

    def Reverse(self) -> "void":
        return _Transfer.Transfer_SequenceOfFinder_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _Transfer.Transfer_SequenceOfFinder_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
        return _Transfer.Transfer_SequenceOfFinder_delNode(theNode, theAl)

    def Clear(self, theAllocator: "opencascade::handle< NCollection_BaseAllocator > const &"=0) -> "void":
        return _Transfer.Transfer_SequenceOfFinder_Clear(self, theAllocator)

    def Assign(self, theOther: "Transfer_SequenceOfFinder") -> "NCollection_Sequence< opencascade::handle< Transfer_Finder > > &":
        return _Transfer.Transfer_SequenceOfFinder_Assign(self, theOther)

    def Set(self, theOther: "Transfer_SequenceOfFinder") -> "NCollection_Sequence< opencascade::handle< Transfer_Finder > > &":
        return _Transfer.Transfer_SequenceOfFinder_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfFinder_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfFinder_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfFinder_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfFinder_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _Transfer.Transfer_SequenceOfFinder_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "Transfer_SequenceOfFinder") -> "void":
        return _Transfer.Transfer_SequenceOfFinder_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< Transfer_Finder > const &":
        return _Transfer.Transfer_SequenceOfFinder_First(self)

    def ChangeFirst(self) -> "opencascade::handle< Transfer_Finder > &":
        return _Transfer.Transfer_SequenceOfFinder_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< Transfer_Finder > const &":
        return _Transfer.Transfer_SequenceOfFinder_Last(self)

    def ChangeLast(self) -> "opencascade::handle< Transfer_Finder > &":
        return _Transfer.Transfer_SequenceOfFinder_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Transfer_Finder > const &":
        return _Transfer.Transfer_SequenceOfFinder_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Transfer_Finder > &":
        return _Transfer.Transfer_SequenceOfFinder_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Transfer_Finder > &":
        return _Transfer.Transfer_SequenceOfFinder___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< Transfer_Finder > const &") -> "void":
        return _Transfer.Transfer_SequenceOfFinder_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _Transfer.delete_Transfer_SequenceOfFinder

    def __len__(self):
        return self.Size()


# Register Transfer_SequenceOfFinder in _Transfer:
_Transfer.Transfer_SequenceOfFinder_swigregister(Transfer_SequenceOfFinder)

def Transfer_SequenceOfFinder_delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
    return _Transfer.Transfer_SequenceOfFinder_delNode(theNode, theAl)

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

    def begin(self) -> "NCollection_IndexedDataMap< opencascade::handle< Transfer_Finder >,opencascade::handle< Transfer_Binder >,Transfer_FindHasher >::iterator":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_begin(self)

    def end(self) -> "NCollection_IndexedDataMap< opencascade::handle< Transfer_Finder >,opencascade::handle< Transfer_Binder >,Transfer_FindHasher >::iterator":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_end(self)

    def cbegin(self) -> "NCollection_IndexedDataMap< opencascade::handle< Transfer_Finder >,opencascade::handle< Transfer_Binder >,Transfer_FindHasher >::const_iterator":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_cbegin(self)

    def cend(self) -> "NCollection_IndexedDataMap< opencascade::handle< Transfer_Finder >,opencascade::handle< Transfer_Binder >,Transfer_FindHasher >::const_iterator":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_cend(self)

    def __init__(self, *args):
        _Transfer.Transfer_TransferMapOfProcessForFinder_swiginit(self, _Transfer.new_Transfer_TransferMapOfProcessForFinder(*args))

    def Exchange(self, theOther: "Transfer_TransferMapOfProcessForFinder") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Exchange(self, theOther)

    def Assign(self, theOther: "Transfer_TransferMapOfProcessForFinder") -> "NCollection_IndexedDataMap< opencascade::handle< Transfer_Finder >,opencascade::handle< Transfer_Binder >,Transfer_FindHasher > &":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Assign(self, theOther)

    def Set(self, theOther: "Transfer_TransferMapOfProcessForFinder") -> "NCollection_IndexedDataMap< opencascade::handle< Transfer_Finder >,opencascade::handle< Transfer_Binder >,Transfer_FindHasher > &":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Set(self, theOther)

    def ReSize(self, N: "Standard_Integer const") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_ReSize(self, N)

    def Add(self, theKey1: "opencascade::handle< Transfer_Finder > const &", theItem: "opencascade::handle< Transfer_Binder > const &") -> "Standard_Integer":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Add(self, theKey1, theItem)

    def Contains(self, theKey1: "opencascade::handle< Transfer_Finder > const &") -> "Standard_Boolean":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "opencascade::handle< Transfer_Finder > const &", theItem: "opencascade::handle< Transfer_Binder > const &") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Substitute(self, theIndex, theKey1, theItem)

    def Swap(self, theIndex1: "Standard_Integer const", theIndex2: "Standard_Integer const") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Swap(self, theIndex1, theIndex2)

    def RemoveLast(self) -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_RemoveLast(self)

    def RemoveFromIndex(self, theIndex: "Standard_Integer const") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_RemoveFromIndex(self, theIndex)

    def RemoveKey(self, theKey1: "opencascade::handle< Transfer_Finder > const &") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Transfer_Finder > const &":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_FindKey(self, theIndex)

    def FindFromIndex(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Transfer_Binder > const &":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_FindFromIndex(self, theIndex)

    def ChangeFromIndex(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_ChangeFromIndex(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_TransferMapOfProcessForFinder___call__(self, *args)

    def FindIndex(self, theKey1: "opencascade::handle< Transfer_Finder > const &") -> "Standard_Integer":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_FindIndex(self, theKey1)

    def ChangeFromKey(self, theKey1: "opencascade::handle< Transfer_Finder > const &") -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_ChangeFromKey(self, theKey1)

    def Seek(self, theKey1: "opencascade::handle< Transfer_Finder > const &") -> "opencascade::handle< Transfer_Binder > const *":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Seek(self, theKey1)

    def ChangeSeek(self, theKey1: "opencascade::handle< Transfer_Finder > const &") -> "opencascade::handle< Transfer_Binder > *":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_ChangeSeek(self, theKey1)

    def FindFromKey(self, *args) -> "Standard_Boolean":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_FindFromKey(self, *args)

    def Clear(self, *args) -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Clear(self, *args)
    __swig_destroy__ = _Transfer.delete_Transfer_TransferMapOfProcessForFinder

    def Size(self) -> "Standard_Integer":
        return _Transfer.Transfer_TransferMapOfProcessForFinder_Size(self)

# Register Transfer_TransferMapOfProcessForFinder in _Transfer:
_Transfer.Transfer_TransferMapOfProcessForFinder_swigregister(Transfer_TransferMapOfProcessForFinder)

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

    def begin(self) -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Transfer_Binder >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_begin(self)

    def end(self) -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Transfer_Binder >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_end(self)

    def cbegin(self) -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Transfer_Binder >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_cbegin(self)

    def cend(self) -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Transfer_Binder >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_cend(self)

    def __init__(self, *args):
        _Transfer.Transfer_TransferMapOfProcessForTransient_swiginit(self, _Transfer.new_Transfer_TransferMapOfProcessForTransient(*args))

    def Exchange(self, theOther: "Transfer_TransferMapOfProcessForTransient") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Exchange(self, theOther)

    def Assign(self, theOther: "Transfer_TransferMapOfProcessForTransient") -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Transfer_Binder >,TColStd_MapTransientHasher > &":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Assign(self, theOther)

    def Set(self, theOther: "Transfer_TransferMapOfProcessForTransient") -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Transfer_Binder >,TColStd_MapTransientHasher > &":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Set(self, theOther)

    def ReSize(self, N: "Standard_Integer const") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_ReSize(self, N)

    def Add(self, theKey1: "opencascade::handle< Standard_Transient > const &", theItem: "opencascade::handle< Transfer_Binder > const &") -> "Standard_Integer":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Add(self, theKey1, theItem)

    def Contains(self, theKey1: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "opencascade::handle< Standard_Transient > const &", theItem: "opencascade::handle< Transfer_Binder > const &") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Substitute(self, theIndex, theKey1, theItem)

    def Swap(self, theIndex1: "Standard_Integer const", theIndex2: "Standard_Integer const") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Swap(self, theIndex1, theIndex2)

    def RemoveLast(self) -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_RemoveLast(self)

    def RemoveFromIndex(self, theIndex: "Standard_Integer const") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_RemoveFromIndex(self, theIndex)

    def RemoveKey(self, theKey1: "opencascade::handle< Standard_Transient > const &") -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > const &":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_FindKey(self, theIndex)

    def FindFromIndex(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Transfer_Binder > const &":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_FindFromIndex(self, theIndex)

    def ChangeFromIndex(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_ChangeFromIndex(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_TransferMapOfProcessForTransient___call__(self, *args)

    def FindIndex(self, theKey1: "opencascade::handle< Standard_Transient > const &") -> "Standard_Integer":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_FindIndex(self, theKey1)

    def ChangeFromKey(self, theKey1: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_Binder > &":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_ChangeFromKey(self, theKey1)

    def Seek(self, theKey1: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_Binder > const *":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Seek(self, theKey1)

    def ChangeSeek(self, theKey1: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Transfer_Binder > *":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_ChangeSeek(self, theKey1)

    def FindFromKey(self, *args) -> "Standard_Boolean":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_FindFromKey(self, *args)

    def Clear(self, *args) -> "void":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Clear(self, *args)
    __swig_destroy__ = _Transfer.delete_Transfer_TransferMapOfProcessForTransient

    def Size(self) -> "Standard_Integer":
        return _Transfer.Transfer_TransferMapOfProcessForTransient_Size(self)

# Register Transfer_TransferMapOfProcessForTransient in _Transfer:
_Transfer.Transfer_TransferMapOfProcessForTransient_swigregister(Transfer_TransferMapOfProcessForTransient)

class Transfer_ActorOfProcessForFinder(OCC.Core.Standard.Standard_Transient):
    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"""
        No available documentation.

        Returns
        -------
        None

        """
        _Transfer.Transfer_ActorOfProcessForFinder_swiginit(self, _Transfer.new_Transfer_ActorOfProcessForFinder(*args))

    def IsLast(self, *args) -> "Standard_Boolean":
        r"""
        Returns the last status (see setlast).

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ActorOfProcessForFinder_IsLast(self, *args)

    def Next(self, *args) -> "opencascade::handle< Transfer_ActorOfProcessForFinder >":
        r"""
        Returns the actor defined as next, or a null handle.

        Returns
        -------
        opencascade::handle<Transfer_ActorOfProcessForFinder>

        """
        return _Transfer.Transfer_ActorOfProcessForFinder_Next(self, *args)

    def NullResult(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Returns a binder for no result, i.e. a null handle.

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ActorOfProcessForFinder_NullResult(self, *args)

    def Recognize(self, *args) -> "Standard_Boolean":
        r"""
        Prerequesite for transfer : the method transfer is called on a starting object only if recognize has returned true on it this allows to define a list of actors, each one processing a definite kind of data transferprocess calls recognize on each one before calling transfer. but even if recognize has returned true, transfer can reject by returning a null binder (afterwards rejection), the next actor is then invoked //! the provided default returns true, can be redefined.

        Parameters
        ----------
        start: Transfer_Finder

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ActorOfProcessForFinder_Recognize(self, *args)

    def SetLast(self, *args) -> "void":
        r"""
        If <mode> is true, commands an actor to be set at the end of the list of actors (see setnext) if it is false (creation default), each add actor is set at the beginning of the list this allows to define default actors (which are last).

        Parameters
        ----------
        mode: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ActorOfProcessForFinder_SetLast(self, *args)

    def SetNext(self, *args) -> "void":
        r"""
        Defines a next actor : it can then be asked to work if <self> produces no result for a given type of object. if next is already set and is not 'last', calls setnext on it. if next defined and 'last', the new actor is added before it in the list.

        Parameters
        ----------
        next: Transfer_ActorOfProcessForFinder

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ActorOfProcessForFinder_SetNext(self, *args)

    def Transferring(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Specific action of transfer. the result is stored in the returned binder, or a null handle for 'no result' (default defined as doing nothing; should be deffered) 'mutable' allows the actor to record intermediate information, in addition to those of transferprocess.

        Parameters
        ----------
        start: Transfer_Finder
        TP: Transfer_ProcessForFinder
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ActorOfProcessForFinder_Transferring(self, *args)

    def TransientResult(self, *args) -> "opencascade::handle< Transfer_SimpleBinderOfTransient >":
        r"""
        Prepares and returns a binder for a transient result returns a null handle if <res> is itself null.

        Parameters
        ----------
        res: Standard_Transient

        Returns
        -------
        opencascade::handle<Transfer_SimpleBinderOfTransient>

        """
        return _Transfer.Transfer_ActorOfProcessForFinder_TransientResult(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_ActorOfProcessForFinder_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_ActorOfProcessForFinder

# Register Transfer_ActorOfProcessForFinder in _Transfer:
_Transfer.Transfer_ActorOfProcessForFinder_swigregister(Transfer_ActorOfProcessForFinder)

class Transfer_ActorOfProcessForTransient(OCC.Core.Standard.Standard_Transient):
    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"""
        No available documentation.

        Returns
        -------
        None

        """
        _Transfer.Transfer_ActorOfProcessForTransient_swiginit(self, _Transfer.new_Transfer_ActorOfProcessForTransient(*args))

    def IsLast(self, *args) -> "Standard_Boolean":
        r"""
        Returns the last status (see setlast).

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ActorOfProcessForTransient_IsLast(self, *args)

    def Next(self, *args) -> "opencascade::handle< Transfer_ActorOfProcessForTransient >":
        r"""
        Returns the actor defined as next, or a null handle.

        Returns
        -------
        opencascade::handle<Transfer_ActorOfProcessForTransient>

        """
        return _Transfer.Transfer_ActorOfProcessForTransient_Next(self, *args)

    def NullResult(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Returns a binder for no result, i.e. a null handle.

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ActorOfProcessForTransient_NullResult(self, *args)

    def Recognize(self, *args) -> "Standard_Boolean":
        r"""
        Prerequesite for transfer : the method transfer is called on a starting object only if recognize has returned true on it this allows to define a list of actors, each one processing a definite kind of data transferprocess calls recognize on each one before calling transfer. but even if recognize has returned true, transfer can reject by returning a null binder (afterwards rejection), the next actor is then invoked //! the provided default returns true, can be redefined.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ActorOfProcessForTransient_Recognize(self, *args)

    def SetLast(self, *args) -> "void":
        r"""
        If <mode> is true, commands an actor to be set at the end of the list of actors (see setnext) if it is false (creation default), each add actor is set at the beginning of the list this allows to define default actors (which are last).

        Parameters
        ----------
        mode: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ActorOfProcessForTransient_SetLast(self, *args)

    def SetNext(self, *args) -> "void":
        r"""
        Defines a next actor : it can then be asked to work if <self> produces no result for a given type of object. if next is already set and is not 'last', calls setnext on it. if next defined and 'last', the new actor is added before it in the list.

        Parameters
        ----------
        next: Transfer_ActorOfProcessForTransient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ActorOfProcessForTransient_SetNext(self, *args)

    def Transferring(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Specific action of transfer. the result is stored in the returned binder, or a null handle for 'no result' (default defined as doing nothing; should be deffered) 'mutable' allows the actor to record intermediate information, in addition to those of transferprocess.

        Parameters
        ----------
        start: Standard_Transient
        TP: Transfer_ProcessForTransient
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ActorOfProcessForTransient_Transferring(self, *args)

    def TransientResult(self, *args) -> "opencascade::handle< Transfer_SimpleBinderOfTransient >":
        r"""
        Prepares and returns a binder for a transient result returns a null handle if <res> is itself null.

        Parameters
        ----------
        res: Standard_Transient

        Returns
        -------
        opencascade::handle<Transfer_SimpleBinderOfTransient>

        """
        return _Transfer.Transfer_ActorOfProcessForTransient_TransientResult(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_ActorOfProcessForTransient_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_ActorOfProcessForTransient

# Register Transfer_ActorOfProcessForTransient in _Transfer:
_Transfer.Transfer_ActorOfProcessForTransient_swigregister(Transfer_ActorOfProcessForTransient)

class Transfer_Binder(OCC.Core.Standard.Standard_Transient):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def AddFail(self, *args) -> "void":
        r"""
        Used to declare an individual transfer as beeing erroneous (status is set to void, statusexec is set to error, <errmess> is added to check's list of fails) it is possible to record several messages of error //! it has same effect for transferprocess as raising an exception during the operation of transfer, except the transfer tries to continue (as if errorhandle had been set).

        Parameters
        ----------
        mess: char *
        orig: char *,optional
        	default value is 

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Binder_AddFail(self, *args)

    def AddResult(self, *args) -> "void":
        r"""
        Adds a next result (at the end of the list) remark : this information is not processed by merge.

        Parameters
        ----------
        next: Transfer_Binder

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Binder_AddResult(self, *args)

    def AddWarning(self, *args) -> "void":
        r"""
        Used to attach a warning message to an individual transfer it has no effect on the status.

        Parameters
        ----------
        mess: char *
        orig: char *,optional
        	default value is 

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Binder_AddWarning(self, *args)

    def CCheck(self, *args) -> "opencascade::handle< Interface_Check >":
        r"""
        Returns check which stores fail messages, in order to modify it (adding messages, or replacing it).

        Returns
        -------
        opencascade::handle<Interface_Check>

        """
        return _Transfer.Transfer_Binder_CCheck(self, *args)

    def Check(self, *args) -> "opencascade::handle< Interface_Check > const":
        r"""
        Returns check which stores fail messages note that no entity is associated in this check.

        Returns
        -------
        opencascade::handle<Interface_Check>

        """
        return _Transfer.Transfer_Binder_Check(self, *args)

    def HasResult(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if a result is available (statusresult = defined) a unique result will be gotten by result (which must be defined in each sub-class according to result type) for a multiple result, see class multiplebinder for other case, specific access has to be forecast.

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_Binder_HasResult(self, *args)

    def IsMultiple(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if a binder has several results, either by itself or because it has next results can be defined by sub-classes.

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_Binder_IsMultiple(self, *args)

    def Merge(self, *args) -> "void":
        r"""
        Merges basic data (check, execstatus) from another binder but keeps its result. used when a binder is replaced by another one, this allows to keep messages.

        Parameters
        ----------
        other: Transfer_Binder

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Binder_Merge(self, *args)

    def NextResult(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Returns the next result, null if none.

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_Binder_NextResult(self, *args)

    def ResultType(self, *args) -> "opencascade::handle< Standard_Type >":
        r"""
        Returns the type which characterizes the result (if known).

        Returns
        -------
        opencascade::handle<Standard_Type>

        """
        return _Transfer.Transfer_Binder_ResultType(self, *args)

    def ResultTypeName(self, *args) -> "char const *":
        r"""
        Returns the name of the type which characterizes the result can be returned even if resulttype itself is unknown.

        Returns
        -------
        char *

        """
        return _Transfer.Transfer_Binder_ResultTypeName(self, *args)

    def SetAlreadyUsed(self, *args) -> "void":
        r"""
        Declares that result is now used by another one, it means that it cannot be modified (by rebind).

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Binder_SetAlreadyUsed(self, *args)

    def SetStatusExec(self, *args) -> "void":
        r"""
        Modifies execution status; called by transferprocess only (for statuserror, rather use seterror, below).

        Parameters
        ----------
        stat: Transfer_StatusExec

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Binder_SetStatusExec(self, *args)

    def Status(self, *args) -> "Transfer_StatusResult":
        r"""
        Returns status, which can be initial (not yet done), made (a result is recorded, not yet shared), used (it is shared and cannot be modified).

        Returns
        -------
        Transfer_StatusResult

        """
        return _Transfer.Transfer_Binder_Status(self, *args)

    def StatusExec(self, *args) -> "Transfer_StatusExec":
        r"""
        Returns execution status.

        Returns
        -------
        Transfer_StatusExec

        """
        return _Transfer.Transfer_Binder_StatusExec(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_Binder_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_Binder

# Register Transfer_Binder in _Transfer:
_Transfer.Transfer_Binder_swigregister(Transfer_Binder)

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

    @staticmethod
    def Type(*args) -> "opencascade::handle< Standard_Type >":
        r"""
        Returns the type attached to an object here, the dynamic type of a transient. null type if unknown.

        Parameters
        ----------
        ent: Standard_Transient

        Returns
        -------
        opencascade::handle<Standard_Type>

        """
        return _Transfer.Transfer_DataInfo_Type(*args)

    @staticmethod
    def TypeName(*args) -> "char const *":
        r"""
        Returns type name (string) allows to name type of non-handled objects.

        Parameters
        ----------
        ent: Standard_Transient

        Returns
        -------
        char *

        """
        return _Transfer.Transfer_DataInfo_TypeName(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _Transfer.Transfer_DataInfo_swiginit(self, _Transfer.new_Transfer_DataInfo())
    __swig_destroy__ = _Transfer.delete_Transfer_DataInfo

# Register Transfer_DataInfo in _Transfer:
_Transfer.Transfer_DataInfo_swigregister(Transfer_DataInfo)

def Transfer_DataInfo_Type(*args) -> "opencascade::handle< Standard_Type >":
    r"""
    Returns the type attached to an object here, the dynamic type of a transient. null type if unknown.

    Parameters
    ----------
    ent: Standard_Transient

    Returns
    -------
    opencascade::handle<Standard_Type>

    """
    return _Transfer.Transfer_DataInfo_Type(*args)

def Transfer_DataInfo_TypeName(*args) -> "char const *":
    r"""
    Returns type name (string) allows to name type of non-handled objects.

    Parameters
    ----------
    ent: Standard_Transient

    Returns
    -------
    char *

    """
    return _Transfer.Transfer_DataInfo_TypeName(*args)

class Transfer_DispatchControl(OCC.Core.Interface.Interface_CopyControl):
    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"""
        Creates the dispatchcontrol, ready for use.

        Parameters
        ----------
        model: Interface_InterfaceModel
        TP: Transfer_TransientProcess

        Returns
        -------
        None

        """
        _Transfer.Transfer_DispatchControl_swiginit(self, _Transfer.new_Transfer_DispatchControl(*args))

    def StartingModel(self, *args) -> "opencascade::handle< Interface_InterfaceModel > const &":
        r"""
        Returns the model from which the transfer is to be done.

        Returns
        -------
        opencascade::handle<Interface_InterfaceModel>

        """
        return _Transfer.Transfer_DispatchControl_StartingModel(self, *args)

    def TransientProcess(self, *args) -> "opencascade::handle< Transfer_TransientProcess > const &":
        r"""
        Returns the content of the dispatchcontrol : it can be used for a direct call, if the basic methods do not suffice.

        Returns
        -------
        opencascade::handle<Transfer_TransientProcess>

        """
        return _Transfer.Transfer_DispatchControl_TransientProcess(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_DispatchControl_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_DispatchControl

# Register Transfer_DispatchControl in _Transfer:
_Transfer.Transfer_DispatchControl_swigregister(Transfer_DispatchControl)

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

    @staticmethod
    def HashCode(*args) -> "Standard_Integer":
        r"""
        Returns hash code for the given finder, in the range [1, theupperbound]. asks the finder its hash code, then transforms it to be in the required range @param thefinder the finder which hash code is to be computed @param theupperbound the upper bound of the range a computing hash code must be within returns a computed hash code, in the range [1, theupperbound].

        Parameters
        ----------
        theFinder: Handle ( Transfer_Finder )
        theUpperBound: int

        Returns
        -------
        int

        """
        return _Transfer.Transfer_FindHasher_HashCode(*args)

    @staticmethod
    def IsEqual(*args) -> "Standard_Boolean":
        r"""
        Returns true if two keys are the same. the test does not work on the finders themselves but by calling their methods equates.

        Parameters
        ----------
        K1: Transfer_Finder
        K2: Transfer_Finder

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_FindHasher_IsEqual(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _Transfer.Transfer_FindHasher_swiginit(self, _Transfer.new_Transfer_FindHasher())
    __swig_destroy__ = _Transfer.delete_Transfer_FindHasher

# Register Transfer_FindHasher in _Transfer:
_Transfer.Transfer_FindHasher_swigregister(Transfer_FindHasher)

def Transfer_FindHasher_HashCode(*args) -> "Standard_Integer":
    r"""
    Returns hash code for the given finder, in the range [1, theupperbound]. asks the finder its hash code, then transforms it to be in the required range @param thefinder the finder which hash code is to be computed @param theupperbound the upper bound of the range a computing hash code must be within returns a computed hash code, in the range [1, theupperbound].

    Parameters
    ----------
    theFinder: Handle ( Transfer_Finder )
    theUpperBound: int

    Returns
    -------
    int

    """
    return _Transfer.Transfer_FindHasher_HashCode(*args)

def Transfer_FindHasher_IsEqual(*args) -> "Standard_Boolean":
    r"""
    Returns true if two keys are the same. the test does not work on the finders themselves but by calling their methods equates.

    Parameters
    ----------
    K1: Transfer_Finder
    K2: Transfer_Finder

    Returns
    -------
    bool

    """
    return _Transfer.Transfer_FindHasher_IsEqual(*args)

class Transfer_Finder(OCC.Core.Standard.Standard_Transient):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def AttrList(self, *args) -> "NCollection_DataMap< TCollection_AsciiString,opencascade::handle< Standard_Transient > > &":
        r"""
        Returns the exhaustive list of attributes.

        Returns
        -------
        NCollection_DataMap<TCollection_AsciiString, opencascade::handle<Standard_Transient>>

        """
        return _Transfer.Transfer_Finder_AttrList(self, *args)

    def Attribute(self, *args) -> "opencascade::handle< Standard_Transient >":
        r"""
        Returns an attribute from its name. null handle if not recorded (whatever transient, integer, real ...).

        Parameters
        ----------
        name: char *

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_Finder_Attribute(self, *args)

    def AttributeType(self, *args) -> "Interface_ParamType":
        r"""
        Returns the type of an attribute : paramint , paramreal , paramtext (string) , paramident (any) or paramvoid (not recorded).

        Parameters
        ----------
        name: char *

        Returns
        -------
        Interface_ParamType

        """
        return _Transfer.Transfer_Finder_AttributeType(self, *args)

    def Equates(self, *args) -> "Standard_Boolean":
        r"""
        Specific testof equallity : to be defined by each sub-class, must be false if finders have not the same true type, else their contents must be compared.

        Parameters
        ----------
        other: Transfer_Finder

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_Finder_Equates(self, *args)

    def GetAttribute(self, *args) -> "Standard_Boolean":
        r"""
        Returns an attribute from its name, filtered by a type if no attribute has this name, or if it is not kind of this type, <val> is null and returned value is false else, it is true.

        Parameters
        ----------
        name: char *
        type: Standard_Type
        val: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_Finder_GetAttribute(self, *args)

    def GetAttributes(self, *args) -> "void":
        r"""
        Gets the list of attributes from <other>, by copying it by default, considers all the attributes from <other> if <fromname> is given, considers only the attributes with name beginning by <fromname> //! for each attribute, if <copied> is true (d), its value is also copied if it is a basic type (integer,real,string), else it remains shared between <other> and <self> //! these new attributes are added to the existing ones in <self>, in case of same name, they replace the existing ones.

        Parameters
        ----------
        other: Transfer_Finder
        fromname: char *,optional
        	default value is 
        copied: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Finder_GetAttributes(self, *args)

    def GetHashCode(self, *args) -> "Standard_Integer":
        r"""
        Returns the hashcode which has been stored by sethashcode (remark that hashcode could be deferred then be defined by sub-classes, the result is the same).

        Returns
        -------
        int

        """
        return _Transfer.Transfer_Finder_GetHashCode(self, *args)

    def GetIntegerAttribute(self, *args) -> "Standard_Boolean":
        r"""
        Returns an attribute from its name, as integer if no attribute has this name, or not an integer, <val> is 0 and returned value is false else, it is true.

        Parameters
        ----------
        name: char *

        Returns
        -------
        val: int

        """
        return _Transfer.Transfer_Finder_GetIntegerAttribute(self, *args)

    def GetRealAttribute(self, *args) -> "Standard_Boolean":
        r"""
        Returns an attribute from its name, as real if no attribute has this name, or not a real <val> is 0.0 and returned value is false else, it is true.

        Parameters
        ----------
        name: char *

        Returns
        -------
        val: float

        """
        return _Transfer.Transfer_Finder_GetRealAttribute(self, *args)

    def GetStringAttribute(self, *args) -> "Standard_Boolean":
        r"""
        Returns an attribute from its name, as string if no attribute has this name, or not a string <val> is 0.0 and returned value is false else, it is true.

        Parameters
        ----------
        name: char *
        val: char *

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_Finder_GetStringAttribute(self, *args)

    def IntegerAttribute(self, *args) -> "Standard_Integer":
        r"""
        Returns an integer attribute from its name. 0 if not recorded.

        Parameters
        ----------
        name: char *

        Returns
        -------
        int

        """
        return _Transfer.Transfer_Finder_IntegerAttribute(self, *args)

    def RealAttribute(self, *args) -> "Standard_Real":
        r"""
        Returns a real attribute from its name. 0.0 if not recorded.

        Parameters
        ----------
        name: char *

        Returns
        -------
        float

        """
        return _Transfer.Transfer_Finder_RealAttribute(self, *args)

    def RemoveAttribute(self, *args) -> "Standard_Boolean":
        r"""
        Removes an attribute returns true when done, false if this attribute did not exist.

        Parameters
        ----------
        name: char *

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_Finder_RemoveAttribute(self, *args)

    def SameAttributes(self, *args) -> "void":
        r"""
        Gets the list of attributes from <other>, as such, i.e. not copied : attributes are shared, any attribute edited, added, or removed in <other> is also in <self> and vice versa the former list of attributes of <self> is dropped.

        Parameters
        ----------
        other: Transfer_Finder

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Finder_SameAttributes(self, *args)

    def SetAttribute(self, *args) -> "void":
        r"""
        Adds an attribute with a given name (replaces the former one with the same name if already exists).

        Parameters
        ----------
        name: char *
        val: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Finder_SetAttribute(self, *args)

    def SetIntegerAttribute(self, *args) -> "void":
        r"""
        Adds an integer value for an attribute.

        Parameters
        ----------
        name: char *
        val: int

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Finder_SetIntegerAttribute(self, *args)

    def SetRealAttribute(self, *args) -> "void":
        r"""
        Adds a real value for an attribute.

        Parameters
        ----------
        name: char *
        val: float

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Finder_SetRealAttribute(self, *args)

    def SetStringAttribute(self, *args) -> "void":
        r"""
        Adds a string value for an attribute.

        Parameters
        ----------
        name: char *
        val: char *

        Returns
        -------
        None

        """
        return _Transfer.Transfer_Finder_SetStringAttribute(self, *args)

    def StringAttribute(self, *args) -> "char const *":
        r"""
        Returns a string attribute from its name. '' if not recorded.

        Parameters
        ----------
        name: char *

        Returns
        -------
        char *

        """
        return _Transfer.Transfer_Finder_StringAttribute(self, *args)

    def ValueType(self, *args) -> "opencascade::handle< Standard_Type >":
        r"""
        Returns the type of the value. by default, returns the dynamictype of <self>, but can be redefined.

        Returns
        -------
        opencascade::handle<Standard_Type>

        """
        return _Transfer.Transfer_Finder_ValueType(self, *args)

    def ValueTypeName(self, *args) -> "char const *":
        r"""
        Returns the name of the type of the value. default is name of valuetype, unless it is for a non-handled object.

        Returns
        -------
        char *

        """
        return _Transfer.Transfer_Finder_ValueTypeName(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_Finder_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_Finder

# Register Transfer_Finder in _Transfer:
_Transfer.Transfer_Finder_swigregister(Transfer_Finder)

class Transfer_MapContainer(OCC.Core.Standard.Standard_Transient):
    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"""
        No available documentation.

        Returns
        -------
        None

        """
        _Transfer.Transfer_MapContainer_swiginit(self, _Transfer.new_Transfer_MapContainer(*args))

    def GetMapObjects(self, *args) -> "TColStd_DataMapOfTransientTransient &":
        r"""
        Get map already translated geometry objects.

        Returns
        -------
        TColStd_DataMapOfTransientTransient

        """
        return _Transfer.Transfer_MapContainer_GetMapObjects(self, *args)

    def SetMapObjects(self, *args) -> "void":
        r"""
        Set map already translated geometry objects.

        Parameters
        ----------
        theMapObjects: TColStd_DataMapOfTransientTransient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_MapContainer_SetMapObjects(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_MapContainer_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_MapContainer

# Register Transfer_MapContainer in _Transfer:
_Transfer.Transfer_MapContainer_swigregister(Transfer_MapContainer)

class Transfer_ProcessForTransient(OCC.Core.Standard.Standard_Transient):
    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"""
        Sets transferprocess at initial state. gives an initial size (indicative) for the map when known (default is 10000). sets default trace file as a printer and default trace level (see message_tracefile).

        Parameters
        ----------
        nb: int,optional
        	default value is 10000

        Returns
        -------
        None
        Sets transferprocess at initial state. gives an initial size (indicative) for the map when known (default is 10000). sets a specified printer.

        Parameters
        ----------
        printer: Message_Messenger
        nb: int,optional
        	default value is 10000

        Returns
        -------
        None

        """
        _Transfer.Transfer_ProcessForTransient_swiginit(self, _Transfer.new_Transfer_ProcessForTransient(*args))

    def AbnormalResult(self, *args) -> "Transfer_IteratorOfProcessForTransient":
        r"""
        Returns binders which are neither 'done' nor 'initial', that is error,loop or run (abnormal states at end of transfer) starting objects are given in correspondance in the iterator.

        Returns
        -------
        Transfer_IteratorOfProcessForTransient

        """
        return _Transfer.Transfer_ProcessForTransient_AbnormalResult(self, *args)

    def Actor(self, *args) -> "opencascade::handle< Transfer_ActorOfProcessForTransient >":
        r"""
        Returns the defined actor. returns a null handle if not set.

        Returns
        -------
        opencascade::handle<Transfer_ActorOfProcessForTransient>

        """
        return _Transfer.Transfer_ProcessForTransient_Actor(self, *args)

    def AddError(self, *args) -> "void":
        r"""
        (other name of addfail, maintained for compatibility).

        Parameters
        ----------
        start: Standard_Transient
        mess: char *
        orig: char *,optional
        	default value is 

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_AddError(self, *args)

    def AddFail(self, *args) -> "void":
        r"""
        Adds an error message to a starting entity (to the check of its binder of category 0, as a fail).

        Parameters
        ----------
        start: Standard_Transient
        mess: char *
        orig: char *,optional
        	default value is 

        Returns
        -------
        None
        Adds an error message to a starting entity from the definition of a msg (original+value).

        Parameters
        ----------
        start: Standard_Transient
        amsg: Message_Msg

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_AddFail(self, *args)

    def AddMultiple(self, *args) -> "void":
        r"""
        Adds an item to a list of results bound to a starting object. considers a category number, by default 0, for all results.

        Parameters
        ----------
        start: Standard_Transient
        res: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_AddMultiple(self, *args)

    def AddWarning(self, *args) -> "void":
        r"""
        Adds a warning message to a starting entity (to the check of its binder of category 0).

        Parameters
        ----------
        start: Standard_Transient
        mess: char *
        orig: char *,optional
        	default value is 

        Returns
        -------
        None
        Adds a warning message to a starting entity from the definition of a msg (original+value).

        Parameters
        ----------
        start: Standard_Transient
        amsg: Message_Msg

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_AddWarning(self, *args)

    def Bind(self, *args) -> "void":
        r"""
        Creates a link a starting object with a binder. this binder can either bring a result (effective binding) or none (it can be set later : pre-binding). considers a category number, by default 0.

        Parameters
        ----------
        start: Standard_Transient
        binder: Transfer_Binder

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_Bind(self, *args)

    def BindMultiple(self, *args) -> "void":
        r"""
        Prepares an object <start> to be bound with several results. if no binder is yet attached to <obj>, a multiplebinder is created, empty. if a binder is already set, it must accept multiple binding. considers a category number, by default 0.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_BindMultiple(self, *args)

    def BindTransient(self, *args) -> "void":
        r"""
        Binds a starting object with a transient result. uses a simplebinderoftransient to work. if there is already one but with no result set, sets its result. considers a category number, by default 0.

        Parameters
        ----------
        start: Standard_Transient
        res: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_BindTransient(self, *args)

    def Check(self, *args) -> "opencascade::handle< Interface_Check >":
        r"""
        Returns the check attached to a starting entity. if <start> is unknown, returns an empty check adds a case name to a starting entity adds a case value to a starting entity returns the complete case list for an entity. null handle if empty in the list of mapped items (between 1 and nbmapped), searches for the first item which follows <num0>(not included) and which has an attribute named <name> attributes are brought by binders hence, allows such an iteration //! for (num = tp->nextitemwithattribute(name,0); num > 0; num = tp->nextitemwithattribute(name,num) { .. process mapped item <num> } returns the type of an attribute attached to binders if this name gives no attribute, returns paramvoid if this name gives several different types, returns parammisc else, returns the effective type (paraminteger, paramreal, paramident, or paramtext) returns the list of recorded attribute names, as a dictionary of integer : each value gives the count of items which bring this attribute name by default, considers all the attribute names if <rootname> is given, considers only the attribute names which begin by <rootname>.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        opencascade::handle<Interface_Check>

        """
        return _Transfer.Transfer_ProcessForTransient_Check(self, *args)

    def CheckList(self, *args) -> "Interface_CheckIterator":
        r"""
        Returns a checklist as a list of check : each one is for a starting entity which have either check (warning or fail) messages are attached, or are in abnormal state : that case gives a specific message if <erronly> is true, checks with warnings only are ignored.

        Parameters
        ----------
        erronly: bool

        Returns
        -------
        Interface_CheckIterator

        """
        return _Transfer.Transfer_ProcessForTransient_CheckList(self, *args)

    def CheckListOne(self, *args) -> "Interface_CheckIterator":
        r"""
        Returns a checklist for one starting object <level> interpreted as by resultone if <erronly> is true, checks with warnings only are ignored.

        Parameters
        ----------
        start: Standard_Transient
        level: int
        erronly: bool

        Returns
        -------
        Interface_CheckIterator

        """
        return _Transfer.Transfer_ProcessForTransient_CheckListOne(self, *args)

    def CheckNum(self, *args) -> "Standard_Integer":
        r"""
        Computes a number to be associated to a starting object in a check or a check-list by default, returns 0; can be redefined.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        int

        """
        return _Transfer.Transfer_ProcessForTransient_CheckNum(self, *args)

    def Clean(self, *args) -> "void":
        r"""
        Rebuilds the map and the roots to really remove unbound items because unbind keeps the entity in place, even if not bound hence, working by checking new items is meaningless if a formerly unbound item is rebound.

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_Clean(self, *args)

    def Clear(self, *args) -> "void":
        r"""
        Resets a transferprocess as ready for a completely new work. clears general data (roots) and the map.

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_Clear(self, *args)

    def CompleteResult(self, *args) -> "Transfer_IteratorOfProcessForTransient":
        r"""
        Returns, as an iterator, the entire log of transfer (list of created objects and binders which can bring errors) if withstart is given true, starting objets are also returned.

        Parameters
        ----------
        withstart: bool,optional
        	default value is Standard_False

        Returns
        -------
        Transfer_IteratorOfProcessForTransient

        """
        return _Transfer.Transfer_ProcessForTransient_CompleteResult(self, *args)

    def ErrorHandle(self, *args) -> "Standard_Boolean":
        r"""
        Returns error handling flag.

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_ErrorHandle(self, *args)

    def Find(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Returns the binder which is linked with a starting object it can either bring a result (transfer done) or none (for a pre-binding). if no binder is linked with <start>, returns a null handle considers a category number, by default 0.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ProcessForTransient_Find(self, *args)

    def FindElseBind(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Returns a binder for a starting entity, as follows : tries to find the already bound one if none found, creates a voidbinder and binds it.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ProcessForTransient_FindElseBind(self, *args)

    def FindTransient(self, *args) -> "opencascade::handle< Standard_Transient > const &":
        r"""
        Returns the result of the transfer of an object <start> as a transient result. returns a null handle if there is no transient result considers a category number, by default 0 warning : supposes that binding is done with a simplebinderoftransient.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_ProcessForTransient_FindTransient(self, *args)

    def FindTypedTransient(self, *args) -> "Standard_Boolean":
        r"""
        Searches for a transient result attached to a starting object, according to its type, by criterium iskind(atype) //! in case of multiple result, explores the list and gives in <val> the first transient result iskind(atype) returns true and fills <val> if found else, returns false (<val> is not touched, not even nullified) //! this syntactic form avoids to do downcast : if a result is found with the good type, it is loaded in <val> and can be immediately used, well initialised.

        Parameters
        ----------
        start: Standard_Transient
        atype: Standard_Type
        val: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_FindTypedTransient(self, *args)

    def GetTypedTransient(self, *args) -> "Standard_Boolean":
        r"""
        Searches for a transient result recorded in a binder, whatever this binder is recorded or not in <self> //! this is strictly equivalent to the class method gettypedresult from class simplebinderoftransient, but is just lighter to call //! apart from this, works as findtypedtransient.

        Parameters
        ----------
        binder: Transfer_Binder
        atype: Standard_Type
        val: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_GetTypedTransient(self, *args)

    def IsAlreadyUsed(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the result of the transfer of an object is already used in other ones. if it is, rebind cannot change it. considers a category number, by default 0.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_IsAlreadyUsed(self, *args)

    def IsBound(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if a result (whatever its form) is bound with a starting object. i.e., if a binder with a result set, is linked with it considers a category number, by default 0.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_IsBound(self, *args)

    def IsCheckListEmpty(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if no check message is attached to a starting object. <level> interpreted as by resultone if <erronly> is true, checks with warnings only are ignored.

        Parameters
        ----------
        start: Standard_Transient
        level: int
        erronly: bool

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_IsCheckListEmpty(self, *args)

    def IsLooping(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if we are surely in a deadloop. evaluation is not exact, it is a 'majorant' which must be computed fast. this 'majorant' is : <alevel> greater than nbmapped.

        Parameters
        ----------
        alevel: int

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_IsLooping(self, *args)

    def MapIndex(self, *args) -> "Standard_Integer":
        r"""
        Returns the index value bound to a starting object, 0 if none.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        int

        """
        return _Transfer.Transfer_ProcessForTransient_MapIndex(self, *args)

    def MapItem(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Returns the binder bound to an index considers a category number, by default 0.

        Parameters
        ----------
        num: int

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ProcessForTransient_MapItem(self, *args)

    def Mapped(self, *args) -> "opencascade::handle< Standard_Transient > const &":
        r"""
        Returns the starting object bound to an index,.

        Parameters
        ----------
        num: int

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_ProcessForTransient_Mapped(self, *args)

    def Mend(self, *args) -> "void":
        r"""
        No available documentation.

        Parameters
        ----------
        start: Standard_Transient
        pref: char *,optional
        	default value is 

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_Mend(self, *args)

    def Messenger(self, *args) -> "opencascade::handle< Message_Messenger >":
        r"""
        Returns messenger used for outputting messages. the returned object is guaranteed to be non-null; default is message::messenger().

        Returns
        -------
        opencascade::handle<Message_Messenger>

        """
        return _Transfer.Transfer_ProcessForTransient_Messenger(self, *args)

    def NbMapped(self, *args) -> "Standard_Integer":
        r"""
        Returns the maximum possible value for map index (no result can be bound with a value greater than it).

        Returns
        -------
        int

        """
        return _Transfer.Transfer_ProcessForTransient_NbMapped(self, *args)

    def NbRoots(self, *args) -> "Standard_Integer":
        r"""
        Returns the count of recorded roots.

        Returns
        -------
        int

        """
        return _Transfer.Transfer_ProcessForTransient_NbRoots(self, *args)

    def NestingLevel(self, *args) -> "Standard_Integer":
        r"""
        Returns nesting level of transfers (managed by methods transcriptwith & co). starts to zero. if no automatic transfer is used, it remains to zero. zero means root level.

        Returns
        -------
        int

        """
        return _Transfer.Transfer_ProcessForTransient_NestingLevel(self, *args)

    def Rebind(self, *args) -> "void":
        r"""
        Changes the binder linked with a starting object for its unitary transfer. this it can be useful when the exact form of the result is known once the transfer is widely engaged. this can be done only on first transfer. considers a category number, by default 0.

        Parameters
        ----------
        start: Standard_Transient
        binder: Transfer_Binder

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_Rebind(self, *args)

    def Recognize(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <start> has been recognized as good candidate for transfer. i.e. queries the actor and its nexts.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_Recognize(self, *args)

    def RemoveResult(self, *args) -> "void":
        r"""
        Removes results attached to (== unbinds) a given object and, according <level> : <level> = 0 : only it <level> = 1 : it plus its immediately owned sub-results(scope) <level> = 2 : it plus all its owned sub-results(scope).

        Parameters
        ----------
        start: Standard_Transient
        level: int
        compute: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_RemoveResult(self, *args)

    def ResetNestingLevel(self, *args) -> "void":
        r"""
        Resets nesting level of transfers to zero (root level), whatever its current value.

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_ResetNestingLevel(self, *args)

    def Resize(self, *args) -> "void":
        r"""
        Resizes the map as required (if a new reliable value has been determined). acts only if <nb> is greater than actual nbmapped.

        Parameters
        ----------
        nb: int

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_Resize(self, *args)

    def ResultOne(self, *args) -> "Transfer_IteratorOfProcessForTransient":
        r"""
        Returns, as an iterator, the log of transfer for one object <level> = 0 : this object only and if <start> is a scope owner (else, <level> is ignored) : <level> = 1 : object plus its immediate scoped ones <level> = 2 : object plus all its scoped ones.

        Parameters
        ----------
        start: Standard_Transient
        level: int
        withstart: bool,optional
        	default value is Standard_False

        Returns
        -------
        Transfer_IteratorOfProcessForTransient

        """
        return _Transfer.Transfer_ProcessForTransient_ResultOne(self, *args)

    def Root(self, *args) -> "opencascade::handle< Standard_Transient > const &":
        r"""
        Returns a root entity given its number in the list (1-nbroots).

        Parameters
        ----------
        num: int

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_ProcessForTransient_Root(self, *args)

    def RootIndex(self, *args) -> "Standard_Integer":
        r"""
        Returns the index in the list of roots for a starting item, or 0 if it is not recorded as a root.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        int

        """
        return _Transfer.Transfer_ProcessForTransient_RootIndex(self, *args)

    def RootItem(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Returns the binder bound with a root entity given its number considers a category number, by default 0.

        Parameters
        ----------
        num: int

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ProcessForTransient_RootItem(self, *args)

    def RootResult(self, *args) -> "Transfer_IteratorOfProcessForTransient":
        r"""
        Returns, as an iterator, the log of root transfer, i.e. the created objects and binders bound to starting roots if withstart is given true, starting objets are also returned.

        Parameters
        ----------
        withstart: bool,optional
        	default value is Standard_False

        Returns
        -------
        Transfer_IteratorOfProcessForTransient

        """
        return _Transfer.Transfer_ProcessForTransient_RootResult(self, *args)

    def SendFail(self, *args) -> "void":
        r"""
        New name for addfail (msg).

        Parameters
        ----------
        start: Standard_Transient
        amsg: Message_Msg

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_SendFail(self, *args)

    def SendMsg(self, *args) -> "void":
        r"""
        Adds an information message trace is filled if trace level is at least 3.

        Parameters
        ----------
        start: Standard_Transient
        amsg: Message_Msg

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_SendMsg(self, *args)

    def SendWarning(self, *args) -> "void":
        r"""
        New name for addwarning (msg).

        Parameters
        ----------
        start: Standard_Transient
        amsg: Message_Msg

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_SendWarning(self, *args)

    def SetActor(self, *args) -> "void":
        r"""
        Defines an actor, which is used for automatic transfer if already defined, the new actor is cumulated (see setnext from actor).

        Parameters
        ----------
        actor: Transfer_ActorOfProcessForTransient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_SetActor(self, *args)

    def SetErrorHandle(self, *args) -> "void":
        r"""
        Allows controls if exceptions will be handled transfer operations <err> false : they are not handled with try {} catch {} <err> true : they are default is false: no handling performed.

        Parameters
        ----------
        err: bool

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_SetErrorHandle(self, *args)

    def SetMessenger(self, *args) -> "void":
        r"""
        Sets messenger used for outputting messages.

        Parameters
        ----------
        messenger: Message_Messenger

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_SetMessenger(self, *args)

    def SetRoot(self, *args) -> "void":
        r"""
        Declares <obj> (and its result) as root. this status will be later exploited by rootresult, see below (result can be produced at any time).

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_SetRoot(self, *args)

    def SetRootManagement(self, *args) -> "void":
        r"""
        Enable (if <stat> true) or disables (if <stat> false) root management. if it is set, transfers are considered as stacked (a first transfer commands other transfers, and so on) and the transfers commanded by an external caller are 'root'. remark : setroot can be called whatever this status, on every object. default is set to true.

        Parameters
        ----------
        stat: bool

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_SetRootManagement(self, *args)

    def SetTraceLevel(self, *args) -> "void":
        r"""
        Sets trace level used for outputting messages: <trace> = 0 : no trace at all <trace> = 1 : handled exceptions and calls to adderror <trace> = 2 : also calls to addwarning <trace> = 3 : also traces new roots (uses method errortrace). default is 1 : errors traced.

        Parameters
        ----------
        tracelev: int

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_SetTraceLevel(self, *args)

    def StartTrace(self, *args) -> "void":
        r"""
        Method called when trace is asked calls printtrace to display information relevant for starting objects (which can be redefined) <level> is nesting level of transfer (0 = root) <mode> controls the way the trace is done : 0 neutral, 1 for error, 2 for warning message, 3 for new root.

        Parameters
        ----------
        binder: Transfer_Binder
        start: Standard_Transient
        level: int
        mode: int

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ProcessForTransient_StartTrace(self, *args)

    def TraceLevel(self, *args) -> "Standard_Integer":
        r"""
        Returns trace level used for outputting messages.

        Returns
        -------
        int

        """
        return _Transfer.Transfer_ProcessForTransient_TraceLevel(self, *args)

    def Transfer(self, *args) -> "Standard_Boolean":
        r"""
        Same as transferring but does not return the binder. simply returns true in case of success (for user call).

        Parameters
        ----------
        start: Standard_Transient
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_Transfer(self, *args)

    def Transferring(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Performs the transfer of a starting object, by calling the method transferproduct (see below). mapping and roots are managed : nothing is done if a result is already bound, an exception is raised in case of error.

        Parameters
        ----------
        start: Standard_Transient
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ProcessForTransient_Transferring(self, *args)

    def Unbind(self, *args) -> "Standard_Boolean":
        r"""
        Removes the binder linked with a starting object if this binder brings a non-empty check, it is replaced by a voidbinder. also removes from the list of roots as required. returns true if done, false if <start> was not bound considers a category number, by default 0.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ProcessForTransient_Unbind(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_ProcessForTransient_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_ProcessForTransient

# Register Transfer_ProcessForTransient in _Transfer:
_Transfer.Transfer_ProcessForTransient_swigregister(Transfer_ProcessForTransient)

class Transfer_ResultFromModel(OCC.Core.Standard.Standard_Transient):
    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"""
        Creates a resultfrommodel, empty.

        Returns
        -------
        None

        """
        _Transfer.Transfer_ResultFromModel_swiginit(self, _Transfer.new_Transfer_ResultFromModel(*args))

    def CheckList(self, *args) -> "Interface_CheckIterator":
        r"""
        Returns the check-list of this set of results <erronly> true : only fails are considered <level> = 0 : considers only main binder <level> = 1 : considers main binder plus immediate subs <level> = 2 (d) : considers all checks.

        Parameters
        ----------
        erronly: bool
        level: int,optional
        	default value is 2

        Returns
        -------
        Interface_CheckIterator

        """
        return _Transfer.Transfer_ResultFromModel_CheckList(self, *args)

    def CheckStatus(self, *args) -> "Interface_CheckStatus":
        r"""
        Returns the check status with corresponds to the content of this resultfrommodel; considers all levels of transfer (worst status). returns checkany if not yet computed reads it from recorded status if already computed, else recomputes one.

        Returns
        -------
        Interface_CheckStatus

        """
        return _Transfer.Transfer_ResultFromModel_CheckStatus(self, *args)

    def CheckedList(self, *args) -> "opencascade::handle< TColStd_HSequenceOfTransient >":
        r"""
        Returns the list of starting entities to which a check status is attached. <check> = -2 , all entities whatever the check (see result) <check> = -1 , entities with no fail (warning allowed) <check> = 0 , entities with no check at all <check> = 1 , entities with warning but no fail <check> = 2 , entities with fail <result> : if true, only entities with an attached result remark : result true and check=0 will give an empty list.

        Parameters
        ----------
        check: Interface_CheckStatus
        result: bool

        Returns
        -------
        opencascade::handle<TColStd_HSequenceOfTransient>

        """
        return _Transfer.Transfer_ResultFromModel_CheckedList(self, *args)

    def ComputeCheckStatus(self, *args) -> "Interface_CheckStatus":
        r"""
        Computes and records check status (see checkstatus) does not computes it if already done and <enforce> false.

        Parameters
        ----------
        enforce: bool

        Returns
        -------
        Interface_CheckStatus

        """
        return _Transfer.Transfer_ResultFromModel_ComputeCheckStatus(self, *args)

    def FileName(self, *args) -> "char const *":
        r"""
        Returns starting file name (empty if not set).

        Returns
        -------
        char *

        """
        return _Transfer.Transfer_ResultFromModel_FileName(self, *args)

    def Fill(self, *args) -> "Standard_Boolean":
        r"""
        Fills from a transientprocess, with the result attached to a starting entity. considers its model if it is set. this action produces a structured set of resultfromtransient, considering scopes, starting by that of <ent>. if <ent> has no recorded result, it remains empty returns true if a result is recorded, false else.

        Parameters
        ----------
        TP: Transfer_TransientProcess
        ent: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ResultFromModel_Fill(self, *args)

    def FillBack(self, *args) -> "void":
        r"""
        Fills back a transientprocess from the structured set of binders. also sets the model.

        Parameters
        ----------
        TP: Transfer_TransientProcess

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromModel_FillBack(self, *args)

    def HasResult(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if a result is recorded.

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ResultFromModel_HasResult(self, *args)

    def MainLabel(self, *args) -> "char const *":
        r"""
        Returns the label in starting model attached to main entity (updated by fill or setmainresult, if model is known).

        Returns
        -------
        char *

        """
        return _Transfer.Transfer_ResultFromModel_MainLabel(self, *args)

    def MainNumber(self, *args) -> "Standard_Integer":
        r"""
        Returns the label in starting model attached to main entity.

        Returns
        -------
        int

        """
        return _Transfer.Transfer_ResultFromModel_MainNumber(self, *args)

    def MainResult(self, *args) -> "opencascade::handle< Transfer_ResultFromTransient >":
        r"""
        Returns the main recorded resultfromtransient, or a null.

        Returns
        -------
        opencascade::handle<Transfer_ResultFromTransient>

        """
        return _Transfer.Transfer_ResultFromModel_MainResult(self, *args)

    def Model(self, *args) -> "opencascade::handle< Interface_InterfaceModel >":
        r"""
        Returns starting model (null if not set).

        Returns
        -------
        opencascade::handle<Interface_InterfaceModel>

        """
        return _Transfer.Transfer_ResultFromModel_Model(self, *args)

    def ResultFromKey(self, *args) -> "opencascade::handle< Transfer_ResultFromTransient >":
        r"""
        Searches for a key (starting entity) and returns its result returns a null handle if not found.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        opencascade::handle<Transfer_ResultFromTransient>

        """
        return _Transfer.Transfer_ResultFromModel_ResultFromKey(self, *args)

    def Results(self, *args) -> "opencascade::handle< TColStd_HSequenceOfTransient >":
        r"""
        Internal method which returns the list of resultfromtransient, according level (2:complete; 1:sub-level 1; 0:main only).

        Parameters
        ----------
        level: int

        Returns
        -------
        opencascade::handle<TColStd_HSequenceOfTransient>

        """
        return _Transfer.Transfer_ResultFromModel_Results(self, *args)

    def SetFileName(self, *args) -> "void":
        r"""
        Sets starting file name.

        Parameters
        ----------
        filename: char *

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromModel_SetFileName(self, *args)

    def SetMainResult(self, *args) -> "void":
        r"""
        Sets a new value for the main recorded resultfromtransient.

        Parameters
        ----------
        amain: Transfer_ResultFromTransient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromModel_SetMainResult(self, *args)

    def SetModel(self, *args) -> "void":
        r"""
        Sets starting model.

        Parameters
        ----------
        model: Interface_InterfaceModel

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromModel_SetModel(self, *args)

    def Strip(self, *args) -> "void":
        r"""
        Clears some data attached to binders used by transientprocess, which become useless once the transfer has been done, by calling strip on its resultfromtransient //! mode = 0 : minimum, clears data remaining from transferprocess mode = 10 : just keeps file name, label, check status ..., and mainresult but only the result (binder) mode = 11 : also clears mainresult (status and names remain).

        Parameters
        ----------
        mode: int

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromModel_Strip(self, *args)

    def TransferredList(self, *args) -> "opencascade::handle< TColStd_HSequenceOfTransient >":
        r"""
        Returns the list of recorded starting entities, ending by the root. entities with check but no transfer result are ignored <level> = 2 (d), considers the complete list <level> = 1 considers the main result plus immediate subs <level> = 0 just the main result.

        Parameters
        ----------
        level: int,optional
        	default value is 2

        Returns
        -------
        opencascade::handle<TColStd_HSequenceOfTransient>

        """
        return _Transfer.Transfer_ResultFromModel_TransferredList(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_ResultFromModel_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_ResultFromModel

# Register Transfer_ResultFromModel in _Transfer:
_Transfer.Transfer_ResultFromModel_swigregister(Transfer_ResultFromModel)

class Transfer_ResultFromTransient(OCC.Core.Standard.Standard_Transient):
    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"""
        Creates a resultfromtransient, empty.

        Returns
        -------
        None

        """
        _Transfer.Transfer_ResultFromTransient_swiginit(self, _Transfer.new_Transfer_ResultFromTransient(*args))

    def AddSubResult(self, *args) -> "void":
        r"""
        Adds a sub-result.

        Parameters
        ----------
        sub: Transfer_ResultFromTransient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromTransient_AddSubResult(self, *args)

    def Binder(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        Returns the binder.

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ResultFromTransient_Binder(self, *args)

    def Check(self, *args) -> "opencascade::handle< Interface_Check > const":
        r"""
        Returns the check (or an empty one if no binder).

        Returns
        -------
        opencascade::handle<Interface_Check>

        """
        return _Transfer.Transfer_ResultFromTransient_Check(self, *args)

    def CheckStatus(self, *args) -> "Interface_CheckStatus":
        r"""
        Returns the check status.

        Returns
        -------
        Interface_CheckStatus

        """
        return _Transfer.Transfer_ResultFromTransient_CheckStatus(self, *args)

    def ClearSubs(self, *args) -> "void":
        r"""
        Clears the list of (immediate) sub-results.

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromTransient_ClearSubs(self, *args)

    def Fill(self, *args) -> "void":
        r"""
        Fills from a transientprocess, with the starting entity which must have been set before. it works with scopes, calls fill on each of its sub-results.

        Parameters
        ----------
        TP: Transfer_TransientProcess

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromTransient_Fill(self, *args)

    def FillBack(self, *args) -> "void":
        r"""
        Fills back a transientprocess with definition of a resultfromtransient, respectfully to its structuration in scopes.

        Parameters
        ----------
        TP: Transfer_TransientProcess

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromTransient_FillBack(self, *args)

    def FillMap(self, *args) -> "void":
        r"""
        This method is used by resultfrommodel to collate the list of resultfromtransient, avoiding duplications with a map remark : <self> is already in the map and has not to be bound.

        Parameters
        ----------
        map: TColStd_IndexedMapOfTransient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromTransient_FillMap(self, *args)

    def HasResult(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if a result is recorded.

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_ResultFromTransient_HasResult(self, *args)

    def NbSubResults(self, *args) -> "Standard_Integer":
        r"""
        Returns the count of recorded sub-results.

        Returns
        -------
        int

        """
        return _Transfer.Transfer_ResultFromTransient_NbSubResults(self, *args)

    def ResultFromKey(self, *args) -> "opencascade::handle< Transfer_ResultFromTransient >":
        r"""
        Returns the resultfromtransient attached to a given starting entity (the key). returns a null handle if not found.

        Parameters
        ----------
        key: Standard_Transient

        Returns
        -------
        opencascade::handle<Transfer_ResultFromTransient>

        """
        return _Transfer.Transfer_ResultFromTransient_ResultFromKey(self, *args)

    def SetBinder(self, *args) -> "void":
        r"""
        Sets binder (for result plus individual check).

        Parameters
        ----------
        binder: Transfer_Binder

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromTransient_SetBinder(self, *args)

    def SetStart(self, *args) -> "void":
        r"""
        Sets starting entity.

        Parameters
        ----------
        start: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromTransient_SetStart(self, *args)

    def Start(self, *args) -> "opencascade::handle< Standard_Transient >":
        r"""
        Returns the starting entity.

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_ResultFromTransient_Start(self, *args)

    def Strip(self, *args) -> "void":
        r"""
        Clears some data attached to binders used by transientprocess, which become useless once the transfer has been done : the list of sub-scoped binders, which is now recorded as sub-results.

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ResultFromTransient_Strip(self, *args)

    def SubResult(self, *args) -> "opencascade::handle< Transfer_ResultFromTransient >":
        r"""
        Returns a sub-result, given its rank.

        Parameters
        ----------
        num: int

        Returns
        -------
        opencascade::handle<Transfer_ResultFromTransient>

        """
        return _Transfer.Transfer_ResultFromTransient_SubResult(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_ResultFromTransient_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_ResultFromTransient

# Register Transfer_ResultFromTransient in _Transfer:
_Transfer.Transfer_ResultFromTransient_swigregister(Transfer_ResultFromTransient)

class Transfer_TransferDispatch(OCC.Core.Interface.Interface_CopyTool):
    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"""
        Creates a transferdispatch from a model. works with a general service library, given as an argument a transferdispatch is created as a copytool in which the control is set to transientprocess.

        Parameters
        ----------
        amodel: Interface_InterfaceModel
        lib: Interface_GeneralLib

        Returns
        -------
        None
        Same as above, but library is defined through a protocol.

        Parameters
        ----------
        amodel: Interface_InterfaceModel
        protocol: Interface_Protocol

        Returns
        -------
        None
        Same as above, but works with the active protocol.

        Parameters
        ----------
        amodel: Interface_InterfaceModel

        Returns
        -------
        None

        """
        _Transfer.Transfer_TransferDispatch_swiginit(self, _Transfer.new_Transfer_TransferDispatch(*args))

    def TransientProcess(self, *args) -> "opencascade::handle< Transfer_TransientProcess >":
        r"""
        Returns the content of control object, as a transientprocess.

        Returns
        -------
        opencascade::handle<Transfer_TransientProcess>

        """
        return _Transfer.Transfer_TransferDispatch_TransientProcess(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_TransferDispatch

# Register Transfer_TransferDispatch in _Transfer:
_Transfer.Transfer_TransferDispatch_swigregister(Transfer_TransferDispatch)

class Transfer_TransferInput(object):
    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"""
        Creates a transferinput ready to use.

        Returns
        -------
        None

        """
        _Transfer.Transfer_TransferInput_swiginit(self, _Transfer.new_Transfer_TransferInput(*args))

    def Entities(self, *args) -> "Interface_EntityIterator":
        r"""
        Takes the transient items stored in a transferiterator.

        Parameters
        ----------
        list: Transfer_TransferIterator

        Returns
        -------
        Interface_EntityIterator

        """
        return _Transfer.Transfer_TransferInput_Entities(self, *args)

    def FillModel(self, *args) -> "void":
        r"""
        Fills an interfacemodel with the complete result of a transfer stored in a transientprocess (starting objects are transient) the complete result is exactly added to the model.

        Parameters
        ----------
        proc: Transfer_TransientProcess
        amodel: Interface_InterfaceModel

        Returns
        -------
        None
        Fills an interfacemodel with results of the transfer recorded in a transientprocess (starting objects are transient) : root result if <roots> is true (default), complete result else the entities added to the model are determined from the result by by adding the referenced entities.

        Parameters
        ----------
        proc: Transfer_TransientProcess
        amodel: Interface_InterfaceModel
        proto: Interface_Protocol
        roots: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Fills an interfacemodel with the complete result of a transfer stored in a transientprocess (starting objects are transient) the complete result is exactly added to the model.

        Parameters
        ----------
        proc: Transfer_FinderProcess
        amodel: Interface_InterfaceModel

        Returns
        -------
        None
        Fills an interfacemodel with results of the transfer recorded in a transientprocess (starting objects are transient) : root result if <roots> is true (default), complete result else the entities added to the model are determined from the result by by adding the referenced entities.

        Parameters
        ----------
        proc: Transfer_FinderProcess
        amodel: Interface_InterfaceModel
        proto: Interface_Protocol
        roots: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferInput_FillModel(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_TransferInput

# Register Transfer_TransferInput in _Transfer:
_Transfer.Transfer_TransferInput_swigregister(Transfer_TransferInput)

class Transfer_TransferIterator(object):
    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"""
        Creates an empty iterator.

        Returns
        -------
        None

        """
        _Transfer.Transfer_TransferIterator_swiginit(self, _Transfer.new_Transfer_TransferIterator(*args))

    def AddItem(self, *args) -> "void":
        r"""
        Adds a binder to the iteration list (construction).

        Parameters
        ----------
        atr: Transfer_Binder

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferIterator_AddItem(self, *args)

    def Check(self, *args) -> "opencascade::handle< Interface_Check > const":
        r"""
        Returns check associated to current binder (in case of error, it brings fail messages) (in case of warnings, it brings warning messages).

        Returns
        -------
        opencascade::handle<Interface_Check>

        """
        return _Transfer.Transfer_TransferIterator_Check(self, *args)

    def HasFails(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if fail messages are recorded with the current binder. they can then be read through check (see below).

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransferIterator_HasFails(self, *args)

    def HasResult(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if current item brings a result, transient (handle) or not or multiple. that is to say, if it corresponds to a normally acheived transfer, transient result is read by specific transientresult below. other kind of result must be read specifically from its binder.

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransferIterator_HasResult(self, *args)

    def HasTransientResult(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the current item has a transient unique result (if yes, use transientresult to get it).

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransferIterator_HasTransientResult(self, *args)

    def HasUniqueResult(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if current item has a unique result.

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransferIterator_HasUniqueResult(self, *args)

    def HasWarnings(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if warning messages are recorded with the current binder. they can then be read through check (see below).

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransferIterator_HasWarnings(self, *args)

    def More(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if there are other items to iterate.

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransferIterator_More(self, *args)

    def Next(self, *args) -> "void":
        r"""
        Sets iteration to the next item.

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferIterator_Next(self, *args)

    def Number(self, *args) -> "Standard_Integer":
        r"""
        Returns count of binders to be iterated.

        Returns
        -------
        int

        """
        return _Transfer.Transfer_TransferIterator_Number(self, *args)

    def ResultType(self, *args) -> "opencascade::handle< Standard_Type >":
        r"""
        Returns the type of the result of the current item, if unique. if no unique result (error transfert or multiple result), returns a null handle the type is : the dynamic type for a transient result, the type defined by the binder class else.

        Returns
        -------
        opencascade::handle<Standard_Type>

        """
        return _Transfer.Transfer_TransferIterator_ResultType(self, *args)

    def SelectBinder(self, *args) -> "void":
        r"""
        Selects items on the type of binder : keep only binders which are of a given type (if keep is true) or reject only them (if keep is false).

        Parameters
        ----------
        atype: Standard_Type
        keep: bool

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferIterator_SelectBinder(self, *args)

    def SelectItem(self, *args) -> "void":
        r"""
        Selects/unselect (according to <keep> an item designated by its rank <num> in the list used by sub-classes which have specific criteria.

        Parameters
        ----------
        num: int
        keep: bool

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferIterator_SelectItem(self, *args)

    def SelectResult(self, *args) -> "void":
        r"""
        Selects items on the type of result. considers only unique results. considers dynamic type for transient result, static type (the one given to define the binder) else. //! results which are of a given type (if keep is true) or reject only them (if keep is false).

        Parameters
        ----------
        atype: Standard_Type
        keep: bool

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferIterator_SelectResult(self, *args)

    def SelectUnique(self, *args) -> "void":
        r"""
        Select items according unicity : keep only unique results (if keep is true) or keep only multiple results (if keep is false).

        Parameters
        ----------
        keep: bool

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferIterator_SelectUnique(self, *args)

    def Start(self, *args) -> "void":
        r"""
        Clears iteration in progress, to allow it to be restarted.

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferIterator_Start(self, *args)

    def Status(self, *args) -> "Transfer_StatusExec":
        r"""
        Returns execution status of current binder normal transfer corresponds to statusdone.

        Returns
        -------
        Transfer_StatusExec

        """
        return _Transfer.Transfer_TransferIterator_Status(self, *args)

    def TransientResult(self, *args) -> "opencascade::handle< Standard_Transient > const &":
        r"""
        Returns the transient result of the current item if there is (else, returns a null handle) supposes that binding is done by a simplebinderoftransient.

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_TransferIterator_TransientResult(self, *args)

    def Value(self, *args) -> "opencascade::handle< Transfer_Binder > const &":
        r"""
        Returns the current binder.

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_TransferIterator_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_TransferIterator

# Register Transfer_TransferIterator in _Transfer:
_Transfer.Transfer_TransferIterator_swigregister(Transfer_TransferIterator)

class Transfer_TransferOutput(object):
    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"""
        Creates a transferoutput ready to use, with a transientprocess.

        Parameters
        ----------
        actor: Transfer_ActorOfTransientProcess
        amodel: Interface_InterfaceModel

        Returns
        -------
        None
        Creates a transferoutput from an already existing transientprocess, and a model returns (by reference, hence can be changed) the mode for scope management. false (d) means scope is ignored. true means that each individual transfer (direct or through transferroots) is regarded as one scope.

        Parameters
        ----------
        proc: Transfer_TransientProcess
        amodel: Interface_InterfaceModel

        Returns
        -------
        None

        """
        _Transfer.Transfer_TransferOutput_swiginit(self, _Transfer.new_Transfer_TransferOutput(*args))

    def ListForStatus(self, *args) -> "Interface_EntityIterator":
        r"""
        Returns the list of starting entities with these criteria : - <normal> false, gives the entities bound with abnormal status (e.g. : fail recorded, exception raised during transfer) - <normal> true, gives entities with or without a result, but with no fail, no exception (warnings are not counted) - <roots> false, considers all entities recorded (either for result, or for at least one fail or warning message) - <roots> true (default), considers only roots of transfer (the entities recorded at highest level) this method is based on abnormalresult from transferprocess.

        Parameters
        ----------
        normal: bool
        roots: bool,optional
        	default value is Standard_True

        Returns
        -------
        Interface_EntityIterator

        """
        return _Transfer.Transfer_TransferOutput_ListForStatus(self, *args)

    def Model(self, *args) -> "opencascade::handle< Interface_InterfaceModel >":
        r"""
        Returns the starting model.

        Returns
        -------
        opencascade::handle<Interface_InterfaceModel>

        """
        return _Transfer.Transfer_TransferOutput_Model(self, *args)

    def ModelForStatus(self, *args) -> "opencascade::handle< Interface_InterfaceModel >":
        r"""
        Fills a model with the list determined by listforstatus this model starts from scratch (made by newemptymodel from the current model), then is filled by addwithrefs //! useful to get separately from a transfer, the entities which have caused problem, in order to furtherly analyse them (with normal = false), or the 'good' entities, to obtain a data set 'which works well' (with normal = true).

        Parameters
        ----------
        protocol: Interface_Protocol
        normal: bool
        roots: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<Interface_InterfaceModel>

        """
        return _Transfer.Transfer_TransferOutput_ModelForStatus(self, *args)

    def Transfer(self, *args) -> "void":
        r"""
        Transfer checks that all taken entities come from the same model, then calls transfer from transientprocess.

        Parameters
        ----------
        obj: Standard_Transient
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferOutput_Transfer(self, *args)

    def TransferRoots(self, *args) -> "void":
        r"""
        Runs transfer on the roots of the interface model the roots are computed with a shareflags created from a protocol given as argument.

        Parameters
        ----------
        protocol: Interface_Protocol
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        None
        Runs transfer on the roots defined by a graph of dependences (which detains also a model and its entities) roots are computed with a shareflags created from the graph.

        Parameters
        ----------
        G: Interface_Graph
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        None
        Runs transfer on the roots of the interface model remark : the roots are computed with a shareflags created from the active protocol.

        Parameters
        ----------
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransferOutput_TransferRoots(self, *args)

    def TransientProcess(self, *args) -> "opencascade::handle< Transfer_TransientProcess >":
        r"""
        Returns the transientprocess used to work.

        Returns
        -------
        opencascade::handle<Transfer_TransientProcess>

        """
        return _Transfer.Transfer_TransferOutput_TransientProcess(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_TransferOutput

# Register Transfer_TransferOutput in _Transfer:
_Transfer.Transfer_TransferOutput_swigregister(Transfer_TransferOutput)

class Transfer_ActorOfFinderProcess(Transfer_ActorOfProcessForFinder):
    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"""
        No available documentation.

        Returns
        -------
        None

        """
        _Transfer.Transfer_ActorOfFinderProcess_swiginit(self, _Transfer.new_Transfer_ActorOfFinderProcess(*args))

    def GetModeTrans(self) -> "Standard_Integer":
        r"""GetModeTrans(Transfer_ActorOfFinderProcess self) -> Standard_Integer"""
        return _Transfer.Transfer_ActorOfFinderProcess_GetModeTrans(self)

    def SetModeTrans(self, value: "Standard_Integer") -> "void":
        r"""SetModeTrans(Transfer_ActorOfFinderProcess self, Standard_Integer value)"""
        return _Transfer.Transfer_ActorOfFinderProcess_SetModeTrans(self, value)

    def Transfer(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        No available documentation.

        Parameters
        ----------
        start: Transfer_Finder
        TP: Transfer_FinderProcess
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ActorOfFinderProcess_Transfer(self, *args)

    def TransferTransient(self, *args) -> "opencascade::handle< Standard_Transient >":
        r"""
        No available documentation.

        Parameters
        ----------
        start: Standard_Transient
        TP: Transfer_FinderProcess
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_ActorOfFinderProcess_TransferTransient(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_ActorOfFinderProcess_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_ActorOfFinderProcess

# Register Transfer_ActorOfFinderProcess in _Transfer:
_Transfer.Transfer_ActorOfFinderProcess_swigregister(Transfer_ActorOfFinderProcess)

class Transfer_ActorOfTransientProcess(Transfer_ActorOfProcessForTransient):
    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"""
        No available documentation.

        Returns
        -------
        None

        """
        _Transfer.Transfer_ActorOfTransientProcess_swiginit(self, _Transfer.new_Transfer_ActorOfTransientProcess(*args))

    def Transfer(self, *args) -> "opencascade::handle< Transfer_Binder >":
        r"""
        No available documentation.

        Parameters
        ----------
        start: Standard_Transient
        TP: Transfer_TransientProcess
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        opencascade::handle<Transfer_Binder>

        """
        return _Transfer.Transfer_ActorOfTransientProcess_Transfer(self, *args)

    def TransferTransient(self, *args) -> "opencascade::handle< Standard_Transient >":
        r"""
        No available documentation.

        Parameters
        ----------
        start: Standard_Transient
        TP: Transfer_TransientProcess
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_ActorOfTransientProcess_TransferTransient(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_ActorOfTransientProcess_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_ActorOfTransientProcess

# Register Transfer_ActorOfTransientProcess in _Transfer:
_Transfer.Transfer_ActorOfTransientProcess_swigregister(Transfer_ActorOfTransientProcess)

class Transfer_FinderProcess(object):
    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"""
        Sets finderprocess at initial state, with an initial size.

        Parameters
        ----------
        nb: int,optional
        	default value is 10000

        Returns
        -------
        None

        """
        _Transfer.Transfer_FinderProcess_swiginit(self, _Transfer.new_Transfer_FinderProcess(*args))

    def Model(self, *args) -> "opencascade::handle< Interface_InterfaceModel >":
        r"""
        Returns the model which can be used for context.

        Returns
        -------
        opencascade::handle<Interface_InterfaceModel>

        """
        return _Transfer.Transfer_FinderProcess_Model(self, *args)

    def NextMappedWithAttribute(self, *args) -> "Standard_Integer":
        r"""
        In the list of mapped items (between 1 and nbmapped), searches for the first mapped item which follows <num0> (not included) and which has an attribute named <name> the considered attributes are those brought by finders,i.e. by input data. while nextitemwithattribute works on result data (binders) //! hence, allows such an iteration //! for (num = fp->nextmappedwithattribute(name,0); num > 0; num = fp->nextmappedwithattribute(name,num) { .. process mapped item <num> }.

        Parameters
        ----------
        name: char *
        num0: int

        Returns
        -------
        int

        """
        return _Transfer.Transfer_FinderProcess_NextMappedWithAttribute(self, *args)

    def SetModel(self, *args) -> "void":
        r"""
        Sets an interfacemodel, which can be used during transfer for instance if a context must be managed, it is in the model.

        Parameters
        ----------
        model: Interface_InterfaceModel

        Returns
        -------
        None

        """
        return _Transfer.Transfer_FinderProcess_SetModel(self, *args)

    def TransientMapper(self, *args) -> "opencascade::handle< Transfer_TransientMapper >":
        r"""
        Returns a transientmapper for a given transient object either <obj> is already mapped, then its mapper is returned or it is not, then a new one is created then returned, but it is not mapped here (use bind or findelsebind to do this).

        Parameters
        ----------
        obj: Standard_Transient

        Returns
        -------
        opencascade::handle<Transfer_TransientMapper>

        """
        return _Transfer.Transfer_FinderProcess_TransientMapper(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_FinderProcess_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_FinderProcess

# Register Transfer_FinderProcess in _Transfer:
_Transfer.Transfer_FinderProcess_swigregister(Transfer_FinderProcess)

class Transfer_IteratorOfProcessForFinder(Transfer_TransferIterator):
    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"""
        Creates an empty iterator if withstarts is true, each binder to be iterated will be associated to its corresponding starting object.

        Parameters
        ----------
        withstarts: bool

        Returns
        -------
        None

        """
        _Transfer.Transfer_IteratorOfProcessForFinder_swiginit(self, _Transfer.new_Transfer_IteratorOfProcessForFinder(*args))

    def Add(self, *args) -> "void":
        r"""
        Adds a binder to the iteration list (construction) with no corresponding starting object (note that result is brought by binder).

        Parameters
        ----------
        binder: Transfer_Binder

        Returns
        -------
        None
        Adds a binder to the iteration list, associated with its corresponding starting object 'start' starting object is ignored if not required at creation time.

        Parameters
        ----------
        binder: Transfer_Binder
        start: Transfer_Finder

        Returns
        -------
        None

        """
        return _Transfer.Transfer_IteratorOfProcessForFinder_Add(self, *args)

    def Filter(self, *args) -> "void":
        r"""
        After having added all items, keeps or rejects items which are attached to starting data given by <only> <keep> = true (d) : keeps. <keep> = false : rejects does nothing if <withstarts> was false.

        Parameters
        ----------
        list: Transfer_HSequenceOfFinder
        keep: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _Transfer.Transfer_IteratorOfProcessForFinder_Filter(self, *args)

    def HasStarting(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if starting object is available (defined at creation time).

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_IteratorOfProcessForFinder_HasStarting(self, *args)

    def Starting(self, *args) -> "opencascade::handle< Transfer_Finder > const &":
        r"""
        Returns corresponding starting object.

        Returns
        -------
        opencascade::handle<Transfer_Finder>

        """
        return _Transfer.Transfer_IteratorOfProcessForFinder_Starting(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_IteratorOfProcessForFinder

# Register Transfer_IteratorOfProcessForFinder in _Transfer:
_Transfer.Transfer_IteratorOfProcessForFinder_swigregister(Transfer_IteratorOfProcessForFinder)

class Transfer_IteratorOfProcessForTransient(Transfer_TransferIterator):
    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"""
        Creates an empty iterator if withstarts is true, each binder to be iterated will be associated to its corresponding starting object.

        Parameters
        ----------
        withstarts: bool

        Returns
        -------
        None

        """
        _Transfer.Transfer_IteratorOfProcessForTransient_swiginit(self, _Transfer.new_Transfer_IteratorOfProcessForTransient(*args))

    def Add(self, *args) -> "void":
        r"""
        Adds a binder to the iteration list (construction) with no corresponding starting object (note that result is brought by binder).

        Parameters
        ----------
        binder: Transfer_Binder

        Returns
        -------
        None
        Adds a binder to the iteration list, associated with its corresponding starting object 'start' starting object is ignored if not required at creation time.

        Parameters
        ----------
        binder: Transfer_Binder
        start: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_IteratorOfProcessForTransient_Add(self, *args)

    def Filter(self, *args) -> "void":
        r"""
        After having added all items, keeps or rejects items which are attached to starting data given by <only> <keep> = true (d) : keeps. <keep> = false : rejects does nothing if <withstarts> was false.

        Parameters
        ----------
        list: TColStd_HSequenceOfTransient
        keep: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _Transfer.Transfer_IteratorOfProcessForTransient_Filter(self, *args)

    def HasStarting(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if starting object is available (defined at creation time).

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_IteratorOfProcessForTransient_HasStarting(self, *args)

    def Starting(self, *args) -> "opencascade::handle< Standard_Transient > const &":
        r"""
        Returns corresponding starting object.

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_IteratorOfProcessForTransient_Starting(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_IteratorOfProcessForTransient

# Register Transfer_IteratorOfProcessForTransient in _Transfer:
_Transfer.Transfer_IteratorOfProcessForTransient_swigregister(Transfer_IteratorOfProcessForTransient)

class Transfer_MultipleBinder(Transfer_Binder):
    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"""
        Normal standard constructor, creates an empty multiplebinder.

        Returns
        -------
        None

        """
        _Transfer.Transfer_MultipleBinder_swiginit(self, _Transfer.new_Transfer_MultipleBinder(*args))

    def AddResult(self, *args) -> "void":
        r"""
        Adds a new item to the multiple result.

        Parameters
        ----------
        res: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_MultipleBinder_AddResult(self, *args)

    def MultipleResult(self, *args) -> "opencascade::handle< TColStd_HSequenceOfTransient >":
        r"""
        Returns the multiple result, if it is defined (at least one item). else, returns a null handle.

        Returns
        -------
        opencascade::handle<TColStd_HSequenceOfTransient>

        """
        return _Transfer.Transfer_MultipleBinder_MultipleResult(self, *args)

    def NbResults(self, *args) -> "Standard_Integer":
        r"""
        Returns the actual count of recorded (transient) results.

        Returns
        -------
        int

        """
        return _Transfer.Transfer_MultipleBinder_NbResults(self, *args)

    def ResultValue(self, *args) -> "opencascade::handle< Standard_Transient >":
        r"""
        Returns the value of the recorded result n0 <num>.

        Parameters
        ----------
        num: int

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_MultipleBinder_ResultValue(self, *args)

    def SetMultipleResult(self, *args) -> "void":
        r"""
        Defines a binding with a multiple result, given as a sequence error if a unique result has yet been defined.

        Parameters
        ----------
        mulres: TColStd_HSequenceOfTransient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_MultipleBinder_SetMultipleResult(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_MultipleBinder_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_MultipleBinder

# Register Transfer_MultipleBinder in _Transfer:
_Transfer.Transfer_MultipleBinder_swigregister(Transfer_MultipleBinder)

class Transfer_SimpleBinderOfTransient(Transfer_Binder):
    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"""
        Creates an empty simplebinderoftransient returns true if a starting object is bound with several results : here, returns allways false see binder itself.

        Returns
        -------
        None

        """
        _Transfer.Transfer_SimpleBinderOfTransient_swiginit(self, _Transfer.new_Transfer_SimpleBinderOfTransient(*args))

    @staticmethod
    def GetTypedResult(*args) -> "Standard_Boolean":
        r"""
        Returns a transient result according to its type (iskind) i.e. the result itself if iskind(atype), else searches in nextresult, until first found, then returns true if not found, returns false (res is not touched) //! this syntactic form avoids to do downcast : if a result is found with the good type, it is loaded in <res> and can be immediately used, well initialised.

        Parameters
        ----------
        bnd: Transfer_Binder
        atype: Standard_Type
        res: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_SimpleBinderOfTransient_GetTypedResult(*args)

    def Result(self, *args) -> "opencascade::handle< Standard_Transient > const &":
        r"""
        Returns the defined result, if there is one.

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_SimpleBinderOfTransient_Result(self, *args)

    def SetResult(self, *args) -> "void":
        r"""
        Defines the result.

        Parameters
        ----------
        res: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_SimpleBinderOfTransient_SetResult(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_SimpleBinderOfTransient_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_SimpleBinderOfTransient

# Register Transfer_SimpleBinderOfTransient in _Transfer:
_Transfer.Transfer_SimpleBinderOfTransient_swigregister(Transfer_SimpleBinderOfTransient)

def Transfer_SimpleBinderOfTransient_GetTypedResult(*args) -> "Standard_Boolean":
    r"""
    Returns a transient result according to its type (iskind) i.e. the result itself if iskind(atype), else searches in nextresult, until first found, then returns true if not found, returns false (res is not touched) //! this syntactic form avoids to do downcast : if a result is found with the good type, it is loaded in <res> and can be immediately used, well initialised.

    Parameters
    ----------
    bnd: Transfer_Binder
    atype: Standard_Type
    res: Standard_Transient

    Returns
    -------
    bool

    """
    return _Transfer.Transfer_SimpleBinderOfTransient_GetTypedResult(*args)

class Transfer_TransientListBinder(Transfer_Binder):
    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"""
        No available documentation.

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        list: TColStd_HSequenceOfTransient

        Returns
        -------
        None

        """
        _Transfer.Transfer_TransientListBinder_swiginit(self, _Transfer.new_Transfer_TransientListBinder(*args))

    def AddResult(self, *args) -> "void":
        r"""
        Adds an item to the result list.

        Parameters
        ----------
        res: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransientListBinder_AddResult(self, *args)

    def NbTransients(self, *args) -> "Standard_Integer":
        r"""
        No available documentation.

        Returns
        -------
        int

        """
        return _Transfer.Transfer_TransientListBinder_NbTransients(self, *args)

    def Result(self, *args) -> "opencascade::handle< TColStd_HSequenceOfTransient >":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<TColStd_HSequenceOfTransient>

        """
        return _Transfer.Transfer_TransientListBinder_Result(self, *args)

    def SetResult(self, *args) -> "void":
        r"""
        Changes an already defined sub-result.

        Parameters
        ----------
        num: int
        res: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransientListBinder_SetResult(self, *args)

    def Transient(self, *args) -> "opencascade::handle< Standard_Transient > const &":
        r"""
        No available documentation.

        Parameters
        ----------
        num: int

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_TransientListBinder_Transient(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_TransientListBinder_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_TransientListBinder

# Register Transfer_TransientListBinder in _Transfer:
_Transfer.Transfer_TransientListBinder_swigregister(Transfer_TransientListBinder)

class Transfer_TransientMapper(Transfer_Finder):
    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"""
        Creates a mapper with a value. this value can then not be changed. it is used by the hasher to compute the hashcode, which will then be stored for an immediate reading.

        Parameters
        ----------
        akey: Standard_Transient

        Returns
        -------
        None

        """
        _Transfer.Transfer_TransientMapper_swiginit(self, _Transfer.new_Transfer_TransientMapper(*args))

    def Value(self, *args) -> "opencascade::handle< Standard_Transient > const &":
        r"""
        Returns the contained value.

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        return _Transfer.Transfer_TransientMapper_Value(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_TransientMapper_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_TransientMapper

# Register Transfer_TransientMapper in _Transfer:
_Transfer.Transfer_TransientMapper_swigregister(Transfer_TransientMapper)

class Transfer_TransientProcess(Transfer_ProcessForTransient):
    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"""
        Sets transientprocess at initial state, with an initial size.

        Parameters
        ----------
        nb: int,optional
        	default value is 10000

        Returns
        -------
        None

        """
        _Transfer.Transfer_TransientProcess_swiginit(self, _Transfer.new_Transfer_TransientProcess(*args))

    def Context(self, *args) -> "NCollection_DataMap< TCollection_AsciiString,opencascade::handle< Standard_Transient > > &":
        r"""
        Returns (modifiable) the whole definition of context rather for internal use (ex.: preparing and setting in once).

        Returns
        -------
        NCollection_DataMap<TCollection_AsciiString, opencascade::handle<Standard_Transient>>

        """
        return _Transfer.Transfer_TransientProcess_Context(self, *args)

    def GetContext(self, *args) -> "Standard_Boolean":
        r"""
        Returns the context attached to a name, if set and if it is kind of the type, else a null handle returns true if ok, false if no context.

        Parameters
        ----------
        name: char *
        type: Standard_Type
        ctx: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransientProcess_GetContext(self, *args)

    def Graph(self, *args) -> "Interface_Graph const &":
        r"""
        No available documentation.

        Returns
        -------
        Interface_Graph

        """
        return _Transfer.Transfer_TransientProcess_Graph(self, *args)

    def HGraph(self, *args) -> "opencascade::handle< Interface_HGraph >":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<Interface_HGraph>

        """
        return _Transfer.Transfer_TransientProcess_HGraph(self, *args)

    def HasGraph(self, *args) -> "Standard_Boolean":
        r"""
        No available documentation.

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransientProcess_HasGraph(self, *args)

    def IsDataFail(self, *args) -> "Standard_Boolean":
        r"""
        Tells if an entity fails on data checking (load time, syntactic, or semantic check). normally, should answer false. it is not prudent to try transferring an entity which fails on data checking.

        Parameters
        ----------
        ent: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransientProcess_IsDataFail(self, *args)

    def IsDataLoaded(self, *args) -> "Standard_Boolean":
        r"""
        Tells if an entity is well loaded from file (even if its data fail on checking, they are present). mostly often, answers true. else, there was a syntactic error in the file. a non-loaded entity may not be transferred, unless its report (in the model) is interpreted.

        Parameters
        ----------
        ent: Standard_Transient

        Returns
        -------
        bool

        """
        return _Transfer.Transfer_TransientProcess_IsDataLoaded(self, *args)

    def Model(self, *args) -> "opencascade::handle< Interface_InterfaceModel >":
        r"""
        Returns the model used for starttrace.

        Returns
        -------
        opencascade::handle<Interface_InterfaceModel>

        """
        return _Transfer.Transfer_TransientProcess_Model(self, *args)

    def RootsForTransfer(self, *args) -> "opencascade::handle< TColStd_HSequenceOfTransient >":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<TColStd_HSequenceOfTransient>

        """
        return _Transfer.Transfer_TransientProcess_RootsForTransfer(self, *args)

    def SetContext(self, *args) -> "void":
        r"""
        Sets a context : according to receiving appli, to be interpreted by the actor.

        Parameters
        ----------
        name: char *
        ctx: Standard_Transient

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransientProcess_SetContext(self, *args)

    def SetGraph(self, *args) -> "void":
        r"""
        Sets a graph : superseedes setmodel if already done.

        Parameters
        ----------
        HG: Interface_HGraph

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransientProcess_SetGraph(self, *args)

    def SetModel(self, *args) -> "void":
        r"""
        Sets an interfacemodel, used by starttrace, checklist, queries on integrity, to give informations significant for each norm.

        Parameters
        ----------
        model: Interface_InterfaceModel

        Returns
        -------
        None

        """
        return _Transfer.Transfer_TransientProcess_SetModel(self, *args)

    def TypedSharings(self, *args) -> "Interface_EntityIterator":
        r"""
        Returns the list of sharings entities, at any level, which are kind of a given type. calls typedsharings from graph returns an empty list if the graph has not been aknowledged.

        Parameters
        ----------
        start: Standard_Transient
        type: Standard_Type

        Returns
        -------
        Interface_EntityIterator

        """
        return _Transfer.Transfer_TransientProcess_TypedSharings(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_TransientProcess_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_TransientProcess

# Register Transfer_TransientProcess in _Transfer:
_Transfer.Transfer_TransientProcess_swigregister(Transfer_TransientProcess)

class Transfer_VoidBinder(Transfer_Binder):
    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"""
        A voidbinder is not multiple (remark : it is not simple too) but it can bring next results ...

        Returns
        -------
        None

        """
        _Transfer.Transfer_VoidBinder_swiginit(self, _Transfer.new_Transfer_VoidBinder(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_VoidBinder_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_VoidBinder

# Register Transfer_VoidBinder in _Transfer:
_Transfer.Transfer_VoidBinder_swigregister(Transfer_VoidBinder)

class Transfer_ActorDispatch(Transfer_ActorOfTransientProcess):
    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"""
        Creates an actordispatch from a model. works with a general service library, given as an argument this causes transferdispatch and its transientprocess to be created, with default actor <self>.

        Parameters
        ----------
        amodel: Interface_InterfaceModel
        lib: Interface_GeneralLib

        Returns
        -------
        None
        Same as above, but library is defined through a protocol.

        Parameters
        ----------
        amodel: Interface_InterfaceModel
        protocol: Interface_Protocol

        Returns
        -------
        None
        Same as above, but works with the active protocol.

        Parameters
        ----------
        amodel: Interface_InterfaceModel

        Returns
        -------
        None

        """
        _Transfer.Transfer_ActorDispatch_swiginit(self, _Transfer.new_Transfer_ActorDispatch(*args))

    def AddActor(self, *args) -> "void":
        r"""
        Utility which adds an actor to the default <self> (it calls setactor from the transientprocess).

        Parameters
        ----------
        actor: Transfer_ActorOfTransientProcess

        Returns
        -------
        None

        """
        return _Transfer.Transfer_ActorDispatch_AddActor(self, *args)

    def TransferDispatch(self, *args) -> "Transfer_TransferDispatch &":
        r"""
        Returns the transferdispatch, which does the work, records the intermediate data, etc... see transferdispatch & copytool, to see the available methods.

        Returns
        -------
        Transfer_TransferDispatch

        """
        return _Transfer.Transfer_ActorDispatch_TransferDispatch(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_ActorDispatch_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_ActorDispatch

# Register Transfer_ActorDispatch in _Transfer:
_Transfer.Transfer_ActorDispatch_swigregister(Transfer_ActorDispatch)

class Transfer_BinderOfTransientInteger(Transfer_SimpleBinderOfTransient):
    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"""
        Creates an empty binderoftransientinteger; default value for the integer part is zero.

        Returns
        -------
        None

        """
        _Transfer.Transfer_BinderOfTransientInteger_swiginit(self, _Transfer.new_Transfer_BinderOfTransientInteger(*args))

    def Integer(self, *args) -> "Standard_Integer":
        r"""
        Returns the value set for the integer part.

        Returns
        -------
        int

        """
        return _Transfer.Transfer_BinderOfTransientInteger_Integer(self, *args)

    def SetInteger(self, *args) -> "void":
        r"""
        Sets a value for the integer part.

        Parameters
        ----------
        value: int

        Returns
        -------
        None

        """
        return _Transfer.Transfer_BinderOfTransientInteger_SetInteger(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_BinderOfTransientInteger_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Transfer.delete_Transfer_BinderOfTransientInteger

# Register Transfer_BinderOfTransientInteger in _Transfer:
_Transfer.Transfer_BinderOfTransientInteger_swigregister(Transfer_BinderOfTransientInteger)


@classnotwrapped
class Transfer_ProcessForFinder:
	pass


class Transfer_HSequenceOfBinder(Transfer_SequenceOfBinder, OCC.Core.Standard.Standard_Transient):
    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):
        _Transfer.Transfer_HSequenceOfBinder_swiginit(self, _Transfer.new_Transfer_HSequenceOfBinder(*args))

    def Sequence(self) -> "Transfer_SequenceOfBinder const &":
        return _Transfer.Transfer_HSequenceOfBinder_Sequence(self)

    def Append(self, *args) -> "void":
        return _Transfer.Transfer_HSequenceOfBinder_Append(self, *args)

    def ChangeSequence(self) -> "Transfer_SequenceOfBinder &":
        return _Transfer.Transfer_HSequenceOfBinder_ChangeSequence(self)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_HSequenceOfBinder_DownCast(t)

    __swig_destroy__ = _Transfer.delete_Transfer_HSequenceOfBinder

# Register Transfer_HSequenceOfBinder in _Transfer:
_Transfer.Transfer_HSequenceOfBinder_swigregister(Transfer_HSequenceOfBinder)

class Transfer_HSequenceOfFinder(Transfer_SequenceOfFinder, OCC.Core.Standard.Standard_Transient):
    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):
        _Transfer.Transfer_HSequenceOfFinder_swiginit(self, _Transfer.new_Transfer_HSequenceOfFinder(*args))

    def Sequence(self) -> "Transfer_SequenceOfFinder const &":
        return _Transfer.Transfer_HSequenceOfFinder_Sequence(self)

    def Append(self, *args) -> "void":
        return _Transfer.Transfer_HSequenceOfFinder_Append(self, *args)

    def ChangeSequence(self) -> "Transfer_SequenceOfFinder &":
        return _Transfer.Transfer_HSequenceOfFinder_ChangeSequence(self)


    @staticmethod
    def DownCast(t):
      return Handle_Transfer_HSequenceOfFinder_DownCast(t)

    __swig_destroy__ = _Transfer.delete_Transfer_HSequenceOfFinder

# Register Transfer_HSequenceOfFinder in _Transfer:
_Transfer.Transfer_HSequenceOfFinder_swigregister(Transfer_HSequenceOfFinder)





