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

"""
BOPDS module, see official documentation at
https://www.opencascade.com/doc/occt-7.4.0/refman/html/package_bopds.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 _BOPDS
else:
    import _BOPDS

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__ = _BOPDS.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _BOPDS:
_BOPDS.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 _BOPDS.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.TColStd
import OCC.Core.TCollection
import OCC.Core.Bnd
import OCC.Core.gp
import OCC.Core.TColgp
import OCC.Core.BVH
import OCC.Core.IntTools
import OCC.Core.BRepAdaptor
import OCC.Core.Adaptor3d
import OCC.Core.Geom
import OCC.Core.GeomAbs
import OCC.Core.TopAbs
import OCC.Core.Adaptor2d
import OCC.Core.Geom2d
import OCC.Core.math
import OCC.Core.Message
import OCC.Core.OSD
import OCC.Core.TopoDS
import OCC.Core.TopLoc
import OCC.Core.GeomAdaptor
import OCC.Core.Geom2dAdaptor
import OCC.Core.Geom2dHatch
import OCC.Core.IntRes2d
import OCC.Core.HatchGen
import OCC.Core.Geom2dInt
import OCC.Core.IntCurve
import OCC.Core.Extrema
import OCC.Core.Intf
import OCC.Core.GeomAPI
import OCC.Core.Approx
import OCC.Core.AppCont
import OCC.Core.AppParCurves
import OCC.Core.BRepClass3d
import OCC.Core.IntCurveSurface
import OCC.Core.IntSurf
import OCC.Core.TopTools
import OCC.Core.IntCurvesFace
import OCC.Core.IntPatch
import OCC.Core.IntAna
import OCC.Core.GeomInt
import OCC.Core.IntImp
import OCC.Core.ApproxInt

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




def Handle_BOPDS_CommonBlock_Create() -> "opencascade::handle< BOPDS_CommonBlock >":
    return _BOPDS.Handle_BOPDS_CommonBlock_Create()

def Handle_BOPDS_CommonBlock_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< BOPDS_CommonBlock >":
    return _BOPDS.Handle_BOPDS_CommonBlock_DownCast(t)

def Handle_BOPDS_CommonBlock_IsNull(t: "opencascade::handle< BOPDS_CommonBlock > const &") -> "bool":
    return _BOPDS.Handle_BOPDS_CommonBlock_IsNull(t)

def Handle_BOPDS_PaveBlock_Create() -> "opencascade::handle< BOPDS_PaveBlock >":
    return _BOPDS.Handle_BOPDS_PaveBlock_Create()

def Handle_BOPDS_PaveBlock_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< BOPDS_PaveBlock >":
    return _BOPDS.Handle_BOPDS_PaveBlock_DownCast(t)

def Handle_BOPDS_PaveBlock_IsNull(t: "opencascade::handle< BOPDS_PaveBlock > const &") -> "bool":
    return _BOPDS.Handle_BOPDS_PaveBlock_IsNull(t)
class BOPDS_DataMapOfIntegerListOfPaveBlock(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_DataMap< int,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< int > >::iterator":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_begin(self)

    def end(self) -> "NCollection_DataMap< int,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< int > >::iterator":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< int > >::const_iterator":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< int > >::const_iterator":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_swiginit(self, _BOPDS.new_BOPDS_DataMapOfIntegerListOfPaveBlock(*args))

    def Exchange(self, theOther: "NCollection_DataMap< Standard_Integer,BOPDS_ListOfPaveBlock,TColStd_MapIntegerHasher > &") -> "void":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Exchange(self, theOther)

    def Assign(self, theOther: "NCollection_DataMap< Standard_Integer,BOPDS_ListOfPaveBlock,TColStd_MapIntegerHasher > const &") -> "NCollection_DataMap< Standard_Integer,BOPDS_ListOfPaveBlock,TColStd_MapIntegerHasher > &":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Assign(self, theOther)

    def Set(self, theOther: "NCollection_DataMap< Standard_Integer,BOPDS_ListOfPaveBlock,TColStd_MapIntegerHasher > const &") -> "NCollection_DataMap< Standard_Integer,BOPDS_ListOfPaveBlock,TColStd_MapIntegerHasher > &":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "BOPDS_ListOfPaveBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "BOPDS_ListOfPaveBlock") -> "BOPDS_ListOfPaveBlock *":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "int const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_IsBound(self, theKey)

    def UnBind(self, theKey: "int const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_UnBind(self, theKey)

    def Seek(self, theKey: "int const &") -> "BOPDS_ListOfPaveBlock const *":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "BOPDS_ListOfPaveBlock *":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_ChangeFind(self, theKey)

    def __call__(self, *args) -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_DataMapOfIntegerListOfPaveBlock

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Size(self)

    def Keys(self) -> "PyObject *":
        return _BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_Keys(self)

# Register BOPDS_DataMapOfIntegerListOfPaveBlock in _BOPDS:
_BOPDS.BOPDS_DataMapOfIntegerListOfPaveBlock_swigregister(BOPDS_DataMapOfIntegerListOfPaveBlock)

class BOPDS_DataMapOfPaveBlockListOfInteger(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_DataMap< opencascade::handle< BOPDS_PaveBlock >,NCollection_List< int >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_begin(self)

    def end(self) -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,NCollection_List< int >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,NCollection_List< int >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,NCollection_List< int >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_swiginit(self, _BOPDS.new_BOPDS_DataMapOfPaveBlockListOfInteger(*args))

    def Exchange(self, theOther: "BOPDS_DataMapOfPaveBlockListOfInteger") -> "void":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_Exchange(self, theOther)

    def Assign(self, theOther: "BOPDS_DataMapOfPaveBlockListOfInteger") -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,TColStd_ListOfInteger,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_DataMapOfPaveBlockListOfInteger") -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,TColStd_ListOfInteger,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_Set(self, theOther)

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

    def Bind(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &", theItem: "TColStd_ListOfInteger") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &", theItem: "TColStd_ListOfInteger") -> "NCollection_List< int > *":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_IsBound(self, theKey)

    def UnBind(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_UnBind(self, theKey)

    def Seek(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "NCollection_List< int > const *":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "NCollection_List< int > *":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "NCollection_List< int > &":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args) -> "NCollection_List< int > &":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_DataMapOfPaveBlockListOfInteger

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_Size(self)

# Register BOPDS_DataMapOfPaveBlockListOfInteger in _BOPDS:
_BOPDS.BOPDS_DataMapOfPaveBlockListOfInteger_swigregister(BOPDS_DataMapOfPaveBlockListOfInteger)

class BOPDS_DataMapOfPaveBlockListOfPaveBlock(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_DataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_begin(self)

    def end(self) -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_end(self)

    def cbegin(self) -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_cbegin(self)

    def cend(self) -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_swiginit(self, _BOPDS.new_BOPDS_DataMapOfPaveBlockListOfPaveBlock(*args))

    def Exchange(self, theOther: "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > &") -> "void":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_Exchange(self, theOther)

    def Assign(self, theOther: "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > const &") -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_Assign(self, theOther)

    def Set(self, theOther: "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > const &") -> "NCollection_DataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_Set(self, theOther)

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

    def Bind(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &", theItem: "BOPDS_ListOfPaveBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_Bind(self, theKey, theItem)

    def Bound(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &", theItem: "BOPDS_ListOfPaveBlock") -> "BOPDS_ListOfPaveBlock *":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_IsBound(self, theKey)

    def UnBind(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_UnBind(self, theKey)

    def Seek(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "BOPDS_ListOfPaveBlock const *":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_Find(self, *args)

    def ChangeSeek(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "BOPDS_ListOfPaveBlock *":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "opencascade::handle< BOPDS_PaveBlock > const &") -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_ChangeFind(self, theKey)

    def __call__(self, *args) -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_DataMapOfPaveBlockListOfPaveBlock

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_Size(self)

# Register BOPDS_DataMapOfPaveBlockListOfPaveBlock in _BOPDS:
_BOPDS.BOPDS_DataMapOfPaveBlockListOfPaveBlock_swigregister(BOPDS_DataMapOfPaveBlockListOfPaveBlock)

class BOPDS_DataMapOfShapeCoupleOfPaveBlocks(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_DataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher >::iterator":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_begin(self)

    def end(self) -> "NCollection_DataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher >::iterator":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_end(self)

    def cbegin(self) -> "NCollection_DataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher >::const_iterator":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_cbegin(self)

    def cend(self) -> "NCollection_DataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher >::const_iterator":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_swiginit(self, _BOPDS.new_BOPDS_DataMapOfShapeCoupleOfPaveBlocks(*args))

    def Exchange(self, theOther: "BOPDS_DataMapOfShapeCoupleOfPaveBlocks") -> "void":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_Exchange(self, theOther)

    def Assign(self, theOther: "BOPDS_DataMapOfShapeCoupleOfPaveBlocks") -> "NCollection_DataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher > &":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_DataMapOfShapeCoupleOfPaveBlocks") -> "NCollection_DataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher > &":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_Set(self, theOther)

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

    def Bind(self, theKey: "TopoDS_Shape", theItem: "BOPDS_CoupleOfPaveBlocks") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_Bind(self, theKey, theItem)

    def Bound(self, theKey: "TopoDS_Shape", theItem: "BOPDS_CoupleOfPaveBlocks") -> "BOPDS_CoupleOfPaveBlocks *":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "TopoDS_Shape") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_IsBound(self, theKey)

    def UnBind(self, theKey: "TopoDS_Shape") -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_UnBind(self, theKey)

    def Seek(self, theKey: "TopoDS_Shape") -> "BOPDS_CoupleOfPaveBlocks const *":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_Find(self, *args)

    def ChangeSeek(self, theKey: "TopoDS_Shape") -> "BOPDS_CoupleOfPaveBlocks *":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "TopoDS_Shape") -> "BOPDS_CoupleOfPaveBlocks &":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_ChangeFind(self, theKey)

    def __call__(self, *args) -> "BOPDS_CoupleOfPaveBlocks &":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_DataMapOfShapeCoupleOfPaveBlocks

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_Size(self)

# Register BOPDS_DataMapOfShapeCoupleOfPaveBlocks in _BOPDS:
_BOPDS.BOPDS_DataMapOfShapeCoupleOfPaveBlocks_swigregister(BOPDS_DataMapOfShapeCoupleOfPaveBlocks)

class BOPDS_IndexedDataMapOfPaveBlockListOfInteger(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< BOPDS_PaveBlock >,NCollection_List< int >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_begin(self)

    def end(self) -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,NCollection_List< int >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_end(self)

    def cbegin(self) -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,NCollection_List< int >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_cbegin(self)

    def cend(self) -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,NCollection_List< int >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_swiginit(self, _BOPDS.new_BOPDS_IndexedDataMapOfPaveBlockListOfInteger(*args))

    def Exchange(self, theOther: "BOPDS_IndexedDataMapOfPaveBlockListOfInteger") -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_Exchange(self, theOther)

    def Assign(self, theOther: "BOPDS_IndexedDataMapOfPaveBlockListOfInteger") -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,TColStd_ListOfInteger,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_IndexedDataMapOfPaveBlockListOfInteger") -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,TColStd_ListOfInteger,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_Set(self, theOther)

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

    def Add(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &", theItem: "TColStd_ListOfInteger") -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_Add(self, theKey1, theItem)

    def Contains(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "opencascade::handle< BOPDS_PaveBlock > const &", theItem: "TColStd_ListOfInteger") -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_Substitute(self, theIndex, theKey1, theItem)

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

    def RemoveLast(self) -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_RemoveLast(self)

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

    def RemoveKey(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "opencascade::handle< BOPDS_PaveBlock > const &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_FindKey(self, theIndex)

    def FindFromIndex(self, theIndex: "Standard_Integer const") -> "NCollection_List< int > const &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_FindFromIndex(self, theIndex)

    def ChangeFromIndex(self, theIndex: "Standard_Integer const") -> "NCollection_List< int > &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_ChangeFromIndex(self, theIndex)

    def __call__(self, *args) -> "NCollection_List< int > &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger___call__(self, *args)

    def FindIndex(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_FindIndex(self, theKey1)

    def ChangeFromKey(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "NCollection_List< int > &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_ChangeFromKey(self, theKey1)

    def Seek(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "NCollection_List< int > const *":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_Seek(self, theKey1)

    def ChangeSeek(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "NCollection_List< int > *":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_ChangeSeek(self, theKey1)

    def FindFromKey(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_FindFromKey(self, *args)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_IndexedDataMapOfPaveBlockListOfInteger

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_Size(self)

# Register BOPDS_IndexedDataMapOfPaveBlockListOfInteger in _BOPDS:
_BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfInteger_swigregister(BOPDS_IndexedDataMapOfPaveBlockListOfInteger)

class BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock(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< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_begin(self)

    def end(self) -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_end(self)

    def cbegin(self) -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_cbegin(self)

    def cend(self) -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_swiginit(self, _BOPDS.new_BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock(*args))

    def Exchange(self, theOther: "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > &") -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_Exchange(self, theOther)

    def Assign(self, theOther: "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > const &") -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_Assign(self, theOther)

    def Set(self, theOther: "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > const &") -> "NCollection_IndexedDataMap< opencascade::handle< BOPDS_PaveBlock >,BOPDS_ListOfPaveBlock,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_Set(self, theOther)

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

    def Add(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &", theItem: "BOPDS_ListOfPaveBlock") -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_Add(self, theKey1, theItem)

    def Contains(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "opencascade::handle< BOPDS_PaveBlock > const &", theItem: "BOPDS_ListOfPaveBlock") -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_Substitute(self, theIndex, theKey1, theItem)

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

    def RemoveLast(self) -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_RemoveLast(self)

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

    def RemoveKey(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "opencascade::handle< BOPDS_PaveBlock > const &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_FindKey(self, theIndex)

    def FindFromIndex(self, theIndex: "Standard_Integer const") -> "BOPDS_ListOfPaveBlock const &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_FindFromIndex(self, theIndex)

    def ChangeFromIndex(self, theIndex: "Standard_Integer const") -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_ChangeFromIndex(self, theIndex)

    def __call__(self, *args) -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock___call__(self, *args)

    def FindIndex(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_FindIndex(self, theKey1)

    def ChangeFromKey(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_ChangeFromKey(self, theKey1)

    def Seek(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "BOPDS_ListOfPaveBlock const *":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_Seek(self, theKey1)

    def ChangeSeek(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "BOPDS_ListOfPaveBlock *":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_ChangeSeek(self, theKey1)

    def FindFromKey(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_FindFromKey(self, *args)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_Size(self)

# Register BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock in _BOPDS:
_BOPDS.BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock_swigregister(BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock)

class BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks(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< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher >::iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_begin(self)

    def end(self) -> "NCollection_IndexedDataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher >::iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_end(self)

    def cbegin(self) -> "NCollection_IndexedDataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher >::const_iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_cbegin(self)

    def cend(self) -> "NCollection_IndexedDataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher >::const_iterator":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_swiginit(self, _BOPDS.new_BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks(*args))

    def Exchange(self, theOther: "BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks") -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_Exchange(self, theOther)

    def Assign(self, theOther: "BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks") -> "NCollection_IndexedDataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher > &":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks") -> "NCollection_IndexedDataMap< TopoDS_Shape,BOPDS_CoupleOfPaveBlocks,TopTools_ShapeMapHasher > &":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_Set(self, theOther)

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

    def Add(self, theKey1: "TopoDS_Shape", theItem: "BOPDS_CoupleOfPaveBlocks") -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_Add(self, theKey1, theItem)

    def Contains(self, theKey1: "TopoDS_Shape") -> "Standard_Boolean":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "TopoDS_Shape", theItem: "BOPDS_CoupleOfPaveBlocks") -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_Substitute(self, theIndex, theKey1, theItem)

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

    def RemoveLast(self) -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_RemoveLast(self)

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

    def RemoveKey(self, theKey1: "TopoDS_Shape") -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "TopoDS_Shape const &":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_FindKey(self, theIndex)

    def FindFromIndex(self, theIndex: "Standard_Integer const") -> "BOPDS_CoupleOfPaveBlocks const &":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_FindFromIndex(self, theIndex)

    def ChangeFromIndex(self, theIndex: "Standard_Integer const") -> "BOPDS_CoupleOfPaveBlocks &":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_ChangeFromIndex(self, theIndex)

    def __call__(self, *args) -> "BOPDS_CoupleOfPaveBlocks &":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks___call__(self, *args)

    def FindIndex(self, theKey1: "TopoDS_Shape") -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_FindIndex(self, theKey1)

    def ChangeFromKey(self, theKey1: "TopoDS_Shape") -> "BOPDS_CoupleOfPaveBlocks &":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_ChangeFromKey(self, theKey1)

    def Seek(self, theKey1: "TopoDS_Shape") -> "BOPDS_CoupleOfPaveBlocks const *":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_Seek(self, theKey1)

    def ChangeSeek(self, theKey1: "TopoDS_Shape") -> "BOPDS_CoupleOfPaveBlocks *":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_ChangeSeek(self, theKey1)

    def FindFromKey(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_FindFromKey(self, *args)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_Size(self)

# Register BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks in _BOPDS:
_BOPDS.BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks_swigregister(BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks)

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

    def cbegin(self) -> "NCollection_IndexedMap< opencascade::handle< BOPDS_PaveBlock >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_cbegin(self)

    def cend(self) -> "NCollection_IndexedMap< opencascade::handle< BOPDS_PaveBlock >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_IndexedMapOfPaveBlock_swiginit(self, _BOPDS.new_BOPDS_IndexedMapOfPaveBlock(*args))

    def Exchange(self, theOther: "BOPDS_IndexedMapOfPaveBlock") -> "void":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_Exchange(self, theOther)

    def Assign(self, theOther: "BOPDS_IndexedMapOfPaveBlock") -> "NCollection_IndexedMap< opencascade::handle< BOPDS_PaveBlock >,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_IndexedMapOfPaveBlock") -> "NCollection_IndexedMap< opencascade::handle< BOPDS_PaveBlock >,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_Set(self, theOther)

    def ReSize(self, theExtent: "Standard_Integer const") -> "void":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_ReSize(self, theExtent)

    def Add(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_Add(self, theKey1)

    def Contains(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "void":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_Substitute(self, theIndex, theKey1)

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

    def RemoveLast(self) -> "void":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_RemoveLast(self)

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

    def RemoveKey(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "opencascade::handle< BOPDS_PaveBlock > const &":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_FindKey(self, theIndex)

    def __call__(self, theIndex: "Standard_Integer const") -> "opencascade::handle< BOPDS_PaveBlock > const &":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock___call__(self, theIndex)

    def FindIndex(self, theKey1: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_FindIndex(self, theKey1)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_IndexedMapOfPaveBlock

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_IndexedMapOfPaveBlock_Size(self)

# Register BOPDS_IndexedMapOfPaveBlock in _BOPDS:
_BOPDS.BOPDS_IndexedMapOfPaveBlock_swigregister(BOPDS_IndexedMapOfPaveBlock)

class BOPDS_ListOfPave(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_List< BOPDS_Pave >::iterator":
        return _BOPDS.BOPDS_ListOfPave_begin(self)

    def end(self) -> "NCollection_List< BOPDS_Pave >::iterator":
        return _BOPDS.BOPDS_ListOfPave_end(self)

    def cbegin(self) -> "NCollection_List< BOPDS_Pave >::const_iterator":
        return _BOPDS.BOPDS_ListOfPave_cbegin(self)

    def cend(self) -> "NCollection_List< BOPDS_Pave >::const_iterator":
        return _BOPDS.BOPDS_ListOfPave_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_ListOfPave_swiginit(self, _BOPDS.new_BOPDS_ListOfPave(*args))

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_ListOfPave_Size(self)

    def Assign(self, theOther: "BOPDS_ListOfPave") -> "NCollection_List< BOPDS_Pave > &":
        return _BOPDS.BOPDS_ListOfPave_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_ListOfPave") -> "NCollection_List< BOPDS_Pave > &":
        return _BOPDS.BOPDS_ListOfPave_Set(self, theOther)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _BOPDS.BOPDS_ListOfPave_Clear(self, theAllocator)

    def First(self) -> "BOPDS_Pave const &":
        return _BOPDS.BOPDS_ListOfPave_First(self)

    def Last(self) -> "BOPDS_Pave const &":
        return _BOPDS.BOPDS_ListOfPave_Last(self)

    def Append(self, *args) -> "void":
        return _BOPDS.BOPDS_ListOfPave_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _BOPDS.BOPDS_ListOfPave_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _BOPDS.BOPDS_ListOfPave_RemoveFirst(self)

    def Remove(self, theIter: "NCollection_List< BOPDS_Pave >::Iterator &") -> "void":
        return _BOPDS.BOPDS_ListOfPave_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _BOPDS.BOPDS_ListOfPave_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _BOPDS.BOPDS_ListOfPave_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _BOPDS.BOPDS_ListOfPave_Reverse(self)
    __swig_destroy__ = _BOPDS.delete_BOPDS_ListOfPave

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


# Register BOPDS_ListOfPave in _BOPDS:
_BOPDS.BOPDS_ListOfPave_swigregister(BOPDS_ListOfPave)

class BOPDS_ListOfPaveBlock(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_List< opencascade::handle< BOPDS_PaveBlock > >::iterator":
        return _BOPDS.BOPDS_ListOfPaveBlock_begin(self)

    def end(self) -> "NCollection_List< opencascade::handle< BOPDS_PaveBlock > >::iterator":
        return _BOPDS.BOPDS_ListOfPaveBlock_end(self)

    def cbegin(self) -> "NCollection_List< opencascade::handle< BOPDS_PaveBlock > >::const_iterator":
        return _BOPDS.BOPDS_ListOfPaveBlock_cbegin(self)

    def cend(self) -> "NCollection_List< opencascade::handle< BOPDS_PaveBlock > >::const_iterator":
        return _BOPDS.BOPDS_ListOfPaveBlock_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_ListOfPaveBlock_swiginit(self, _BOPDS.new_BOPDS_ListOfPaveBlock(*args))

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_ListOfPaveBlock_Size(self)

    def Assign(self, theOther: "BOPDS_ListOfPaveBlock") -> "NCollection_List< opencascade::handle< BOPDS_PaveBlock > > &":
        return _BOPDS.BOPDS_ListOfPaveBlock_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_ListOfPaveBlock") -> "NCollection_List< opencascade::handle< BOPDS_PaveBlock > > &":
        return _BOPDS.BOPDS_ListOfPaveBlock_Set(self, theOther)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _BOPDS.BOPDS_ListOfPaveBlock_Clear(self, theAllocator)

    def First(self) -> "opencascade::handle< BOPDS_PaveBlock > const &":
        return _BOPDS.BOPDS_ListOfPaveBlock_First(self)

    def Last(self) -> "opencascade::handle< BOPDS_PaveBlock > const &":
        return _BOPDS.BOPDS_ListOfPaveBlock_Last(self)

    def Append(self, *args) -> "void":
        return _BOPDS.BOPDS_ListOfPaveBlock_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _BOPDS.BOPDS_ListOfPaveBlock_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _BOPDS.BOPDS_ListOfPaveBlock_RemoveFirst(self)

    def Remove(self, theIter: "NCollection_List< opencascade::handle< BOPDS_PaveBlock > >::Iterator &") -> "void":
        return _BOPDS.BOPDS_ListOfPaveBlock_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _BOPDS.BOPDS_ListOfPaveBlock_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _BOPDS.BOPDS_ListOfPaveBlock_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _BOPDS.BOPDS_ListOfPaveBlock_Reverse(self)
    __swig_destroy__ = _BOPDS.delete_BOPDS_ListOfPaveBlock

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


# Register BOPDS_ListOfPaveBlock in _BOPDS:
_BOPDS.BOPDS_ListOfPaveBlock_swigregister(BOPDS_ListOfPaveBlock)

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

    def cbegin(self) -> "NCollection_Map< opencascade::handle< BOPDS_CommonBlock >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_MapOfCommonBlock_cbegin(self)

    def cend(self) -> "NCollection_Map< opencascade::handle< BOPDS_CommonBlock >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_MapOfCommonBlock_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_MapOfCommonBlock_swiginit(self, _BOPDS.new_BOPDS_MapOfCommonBlock(*args))

    def Exchange(self, theOther: "BOPDS_MapOfCommonBlock") -> "void":
        return _BOPDS.BOPDS_MapOfCommonBlock_Exchange(self, theOther)

    def Assign(self, theOther: "BOPDS_MapOfCommonBlock") -> "NCollection_Map< opencascade::handle< BOPDS_CommonBlock >,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_MapOfCommonBlock_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_MapOfCommonBlock") -> "NCollection_Map< opencascade::handle< BOPDS_CommonBlock >,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_MapOfCommonBlock_Set(self, theOther)

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

    def Add(self, K: "opencascade::handle< BOPDS_CommonBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfCommonBlock_Add(self, K)

    def Added(self, K: "opencascade::handle< BOPDS_CommonBlock > const &") -> "opencascade::handle< BOPDS_CommonBlock > const &":
        return _BOPDS.BOPDS_MapOfCommonBlock_Added(self, K)

    def Remove(self, K: "opencascade::handle< BOPDS_CommonBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfCommonBlock_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_MapOfCommonBlock_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_MapOfCommonBlock

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_MapOfCommonBlock_Size(self)

    def IsEqual(self, theOther: "BOPDS_MapOfCommonBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfCommonBlock_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfCommonBlock_Contains(self, *args)

    def Union(self, theLeft: "BOPDS_MapOfCommonBlock", theRight: "BOPDS_MapOfCommonBlock") -> "void":
        return _BOPDS.BOPDS_MapOfCommonBlock_Union(self, theLeft, theRight)

    def Unite(self, theOther: "BOPDS_MapOfCommonBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfCommonBlock_Unite(self, theOther)

    def HasIntersection(self, theMap: "BOPDS_MapOfCommonBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfCommonBlock_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "BOPDS_MapOfCommonBlock", theRight: "BOPDS_MapOfCommonBlock") -> "void":
        return _BOPDS.BOPDS_MapOfCommonBlock_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "BOPDS_MapOfCommonBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfCommonBlock_Intersect(self, theOther)

    def Subtraction(self, theLeft: "BOPDS_MapOfCommonBlock", theRight: "BOPDS_MapOfCommonBlock") -> "void":
        return _BOPDS.BOPDS_MapOfCommonBlock_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "BOPDS_MapOfCommonBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfCommonBlock_Subtract(self, theOther)

    def Difference(self, theLeft: "BOPDS_MapOfCommonBlock", theRight: "BOPDS_MapOfCommonBlock") -> "void":
        return _BOPDS.BOPDS_MapOfCommonBlock_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "BOPDS_MapOfCommonBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfCommonBlock_Differ(self, theOther)

# Register BOPDS_MapOfCommonBlock in _BOPDS:
_BOPDS.BOPDS_MapOfCommonBlock_swigregister(BOPDS_MapOfCommonBlock)

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

    def cbegin(self) -> "NCollection_Map< BOPDS_Pair,BOPDS_PairMapHasher >::const_iterator":
        return _BOPDS.BOPDS_MapOfPair_cbegin(self)

    def cend(self) -> "NCollection_Map< BOPDS_Pair,BOPDS_PairMapHasher >::const_iterator":
        return _BOPDS.BOPDS_MapOfPair_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_MapOfPair_swiginit(self, _BOPDS.new_BOPDS_MapOfPair(*args))

    def Exchange(self, theOther: "BOPDS_MapOfPair") -> "void":
        return _BOPDS.BOPDS_MapOfPair_Exchange(self, theOther)

    def Assign(self, theOther: "BOPDS_MapOfPair") -> "NCollection_Map< BOPDS_Pair,BOPDS_PairMapHasher > &":
        return _BOPDS.BOPDS_MapOfPair_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_MapOfPair") -> "NCollection_Map< BOPDS_Pair,BOPDS_PairMapHasher > &":
        return _BOPDS.BOPDS_MapOfPair_Set(self, theOther)

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

    def Add(self, K: "BOPDS_Pair") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPair_Add(self, K)

    def Added(self, K: "BOPDS_Pair") -> "BOPDS_Pair const &":
        return _BOPDS.BOPDS_MapOfPair_Added(self, K)

    def Remove(self, K: "BOPDS_Pair") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPair_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_MapOfPair_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_MapOfPair

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_MapOfPair_Size(self)

    def IsEqual(self, theOther: "BOPDS_MapOfPair") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPair_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPair_Contains(self, *args)

    def Union(self, theLeft: "BOPDS_MapOfPair", theRight: "BOPDS_MapOfPair") -> "void":
        return _BOPDS.BOPDS_MapOfPair_Union(self, theLeft, theRight)

    def Unite(self, theOther: "BOPDS_MapOfPair") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPair_Unite(self, theOther)

    def HasIntersection(self, theMap: "BOPDS_MapOfPair") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPair_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "BOPDS_MapOfPair", theRight: "BOPDS_MapOfPair") -> "void":
        return _BOPDS.BOPDS_MapOfPair_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "BOPDS_MapOfPair") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPair_Intersect(self, theOther)

    def Subtraction(self, theLeft: "BOPDS_MapOfPair", theRight: "BOPDS_MapOfPair") -> "void":
        return _BOPDS.BOPDS_MapOfPair_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "BOPDS_MapOfPair") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPair_Subtract(self, theOther)

    def Difference(self, theLeft: "BOPDS_MapOfPair", theRight: "BOPDS_MapOfPair") -> "void":
        return _BOPDS.BOPDS_MapOfPair_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "BOPDS_MapOfPair") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPair_Differ(self, theOther)

# Register BOPDS_MapOfPair in _BOPDS:
_BOPDS.BOPDS_MapOfPair_swigregister(BOPDS_MapOfPair)

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

    def cbegin(self) -> "NCollection_Map< BOPDS_Pave,BOPDS_PaveMapHasher >::const_iterator":
        return _BOPDS.BOPDS_MapOfPave_cbegin(self)

    def cend(self) -> "NCollection_Map< BOPDS_Pave,BOPDS_PaveMapHasher >::const_iterator":
        return _BOPDS.BOPDS_MapOfPave_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_MapOfPave_swiginit(self, _BOPDS.new_BOPDS_MapOfPave(*args))

    def Exchange(self, theOther: "BOPDS_MapOfPave") -> "void":
        return _BOPDS.BOPDS_MapOfPave_Exchange(self, theOther)

    def Assign(self, theOther: "BOPDS_MapOfPave") -> "NCollection_Map< BOPDS_Pave,BOPDS_PaveMapHasher > &":
        return _BOPDS.BOPDS_MapOfPave_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_MapOfPave") -> "NCollection_Map< BOPDS_Pave,BOPDS_PaveMapHasher > &":
        return _BOPDS.BOPDS_MapOfPave_Set(self, theOther)

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

    def Add(self, K: "BOPDS_Pave") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPave_Add(self, K)

    def Added(self, K: "BOPDS_Pave") -> "BOPDS_Pave const &":
        return _BOPDS.BOPDS_MapOfPave_Added(self, K)

    def Remove(self, K: "BOPDS_Pave") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPave_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_MapOfPave_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_MapOfPave

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_MapOfPave_Size(self)

    def IsEqual(self, theOther: "BOPDS_MapOfPave") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPave_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPave_Contains(self, *args)

    def Union(self, theLeft: "BOPDS_MapOfPave", theRight: "BOPDS_MapOfPave") -> "void":
        return _BOPDS.BOPDS_MapOfPave_Union(self, theLeft, theRight)

    def Unite(self, theOther: "BOPDS_MapOfPave") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPave_Unite(self, theOther)

    def HasIntersection(self, theMap: "BOPDS_MapOfPave") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPave_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "BOPDS_MapOfPave", theRight: "BOPDS_MapOfPave") -> "void":
        return _BOPDS.BOPDS_MapOfPave_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "BOPDS_MapOfPave") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPave_Intersect(self, theOther)

    def Subtraction(self, theLeft: "BOPDS_MapOfPave", theRight: "BOPDS_MapOfPave") -> "void":
        return _BOPDS.BOPDS_MapOfPave_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "BOPDS_MapOfPave") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPave_Subtract(self, theOther)

    def Difference(self, theLeft: "BOPDS_MapOfPave", theRight: "BOPDS_MapOfPave") -> "void":
        return _BOPDS.BOPDS_MapOfPave_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "BOPDS_MapOfPave") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPave_Differ(self, theOther)

# Register BOPDS_MapOfPave in _BOPDS:
_BOPDS.BOPDS_MapOfPave_swigregister(BOPDS_MapOfPave)

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

    def cbegin(self) -> "NCollection_Map< opencascade::handle< BOPDS_PaveBlock >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_MapOfPaveBlock_cbegin(self)

    def cend(self) -> "NCollection_Map< opencascade::handle< BOPDS_PaveBlock >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _BOPDS.BOPDS_MapOfPaveBlock_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_MapOfPaveBlock_swiginit(self, _BOPDS.new_BOPDS_MapOfPaveBlock(*args))

    def Exchange(self, theOther: "BOPDS_MapOfPaveBlock") -> "void":
        return _BOPDS.BOPDS_MapOfPaveBlock_Exchange(self, theOther)

    def Assign(self, theOther: "BOPDS_MapOfPaveBlock") -> "NCollection_Map< opencascade::handle< BOPDS_PaveBlock >,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_MapOfPaveBlock_Assign(self, theOther)

    def Set(self, theOther: "BOPDS_MapOfPaveBlock") -> "NCollection_Map< opencascade::handle< BOPDS_PaveBlock >,TColStd_MapTransientHasher > &":
        return _BOPDS.BOPDS_MapOfPaveBlock_Set(self, theOther)

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

    def Add(self, K: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPaveBlock_Add(self, K)

    def Added(self, K: "opencascade::handle< BOPDS_PaveBlock > const &") -> "opencascade::handle< BOPDS_PaveBlock > const &":
        return _BOPDS.BOPDS_MapOfPaveBlock_Added(self, K)

    def Remove(self, K: "opencascade::handle< BOPDS_PaveBlock > const &") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPaveBlock_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _BOPDS.BOPDS_MapOfPaveBlock_Clear(self, *args)
    __swig_destroy__ = _BOPDS.delete_BOPDS_MapOfPaveBlock

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_MapOfPaveBlock_Size(self)

    def IsEqual(self, theOther: "BOPDS_MapOfPaveBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPaveBlock_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPaveBlock_Contains(self, *args)

    def Union(self, theLeft: "BOPDS_MapOfPaveBlock", theRight: "BOPDS_MapOfPaveBlock") -> "void":
        return _BOPDS.BOPDS_MapOfPaveBlock_Union(self, theLeft, theRight)

    def Unite(self, theOther: "BOPDS_MapOfPaveBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPaveBlock_Unite(self, theOther)

    def HasIntersection(self, theMap: "BOPDS_MapOfPaveBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPaveBlock_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "BOPDS_MapOfPaveBlock", theRight: "BOPDS_MapOfPaveBlock") -> "void":
        return _BOPDS.BOPDS_MapOfPaveBlock_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "BOPDS_MapOfPaveBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPaveBlock_Intersect(self, theOther)

    def Subtraction(self, theLeft: "BOPDS_MapOfPaveBlock", theRight: "BOPDS_MapOfPaveBlock") -> "void":
        return _BOPDS.BOPDS_MapOfPaveBlock_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "BOPDS_MapOfPaveBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPaveBlock_Subtract(self, theOther)

    def Difference(self, theLeft: "BOPDS_MapOfPaveBlock", theRight: "BOPDS_MapOfPaveBlock") -> "void":
        return _BOPDS.BOPDS_MapOfPaveBlock_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "BOPDS_MapOfPaveBlock") -> "Standard_Boolean":
        return _BOPDS.BOPDS_MapOfPaveBlock_Differ(self, theOther)

# Register BOPDS_MapOfPaveBlock in _BOPDS:
_BOPDS.BOPDS_MapOfPaveBlock_swigregister(BOPDS_MapOfPaveBlock)

class BOPDS_VectorOfCurve(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_Vector< BOPDS_Curve >::iterator":
        return _BOPDS.BOPDS_VectorOfCurve_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_Curve >::iterator":
        return _BOPDS.BOPDS_VectorOfCurve_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_Curve >::const_iterator":
        return _BOPDS.BOPDS_VectorOfCurve_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_Curve >::const_iterator":
        return _BOPDS.BOPDS_VectorOfCurve_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfCurve_swiginit(self, _BOPDS.new_BOPDS_VectorOfCurve(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfCurve

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfCurve_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfCurve_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfCurve_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfCurve_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfCurve_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfCurve_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfCurve") -> "NCollection_Vector< BOPDS_Curve > &":
        return _BOPDS.BOPDS_VectorOfCurve_Set(self, theOther)

    def Append(self, theValue: "BOPDS_Curve") -> "BOPDS_Curve &":
        return _BOPDS.BOPDS_VectorOfCurve_Append(self, theValue)

    def Appended(self) -> "BOPDS_Curve &":
        return _BOPDS.BOPDS_VectorOfCurve_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_Curve const &":
        return _BOPDS.BOPDS_VectorOfCurve_Value(self, theIndex)

    def First(self) -> "BOPDS_Curve const &":
        return _BOPDS.BOPDS_VectorOfCurve_First(self)

    def ChangeFirst(self) -> "BOPDS_Curve &":
        return _BOPDS.BOPDS_VectorOfCurve_ChangeFirst(self)

    def Last(self) -> "BOPDS_Curve const &":
        return _BOPDS.BOPDS_VectorOfCurve_Last(self)

    def ChangeLast(self) -> "BOPDS_Curve &":
        return _BOPDS.BOPDS_VectorOfCurve_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_Curve &":
        return _BOPDS.BOPDS_VectorOfCurve___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_Curve &":
        return _BOPDS.BOPDS_VectorOfCurve_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_Curve") -> "BOPDS_Curve &":
        return _BOPDS.BOPDS_VectorOfCurve_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfCurve in _BOPDS:
_BOPDS.BOPDS_VectorOfCurve_swigregister(BOPDS_VectorOfCurve)

class BOPDS_VectorOfFaceInfo(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_Vector< BOPDS_FaceInfo >::iterator":
        return _BOPDS.BOPDS_VectorOfFaceInfo_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_FaceInfo >::iterator":
        return _BOPDS.BOPDS_VectorOfFaceInfo_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_FaceInfo >::const_iterator":
        return _BOPDS.BOPDS_VectorOfFaceInfo_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_FaceInfo >::const_iterator":
        return _BOPDS.BOPDS_VectorOfFaceInfo_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfFaceInfo_swiginit(self, _BOPDS.new_BOPDS_VectorOfFaceInfo(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfFaceInfo

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfFaceInfo_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfFaceInfo") -> "NCollection_Vector< BOPDS_FaceInfo > &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Set(self, theOther)

    def Append(self, theValue: "BOPDS_FaceInfo") -> "BOPDS_FaceInfo &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Append(self, theValue)

    def Appended(self) -> "BOPDS_FaceInfo &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_FaceInfo const &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Value(self, theIndex)

    def First(self) -> "BOPDS_FaceInfo const &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_First(self)

    def ChangeFirst(self) -> "BOPDS_FaceInfo &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_ChangeFirst(self)

    def Last(self) -> "BOPDS_FaceInfo const &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_Last(self)

    def ChangeLast(self) -> "BOPDS_FaceInfo &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_FaceInfo &":
        return _BOPDS.BOPDS_VectorOfFaceInfo___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_FaceInfo &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_FaceInfo") -> "BOPDS_FaceInfo &":
        return _BOPDS.BOPDS_VectorOfFaceInfo_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfFaceInfo in _BOPDS:
_BOPDS.BOPDS_VectorOfFaceInfo_swigregister(BOPDS_VectorOfFaceInfo)

class BOPDS_VectorOfIndexRange(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_Vector< BOPDS_IndexRange >::iterator":
        return _BOPDS.BOPDS_VectorOfIndexRange_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_IndexRange >::iterator":
        return _BOPDS.BOPDS_VectorOfIndexRange_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_IndexRange >::const_iterator":
        return _BOPDS.BOPDS_VectorOfIndexRange_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_IndexRange >::const_iterator":
        return _BOPDS.BOPDS_VectorOfIndexRange_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfIndexRange_swiginit(self, _BOPDS.new_BOPDS_VectorOfIndexRange(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfIndexRange

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfIndexRange_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfIndexRange_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfIndexRange_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfIndexRange_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfIndexRange_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfIndexRange_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfIndexRange") -> "NCollection_Vector< BOPDS_IndexRange > &":
        return _BOPDS.BOPDS_VectorOfIndexRange_Set(self, theOther)

    def Append(self, theValue: "BOPDS_IndexRange") -> "BOPDS_IndexRange &":
        return _BOPDS.BOPDS_VectorOfIndexRange_Append(self, theValue)

    def Appended(self) -> "BOPDS_IndexRange &":
        return _BOPDS.BOPDS_VectorOfIndexRange_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_IndexRange const &":
        return _BOPDS.BOPDS_VectorOfIndexRange_Value(self, theIndex)

    def First(self) -> "BOPDS_IndexRange const &":
        return _BOPDS.BOPDS_VectorOfIndexRange_First(self)

    def ChangeFirst(self) -> "BOPDS_IndexRange &":
        return _BOPDS.BOPDS_VectorOfIndexRange_ChangeFirst(self)

    def Last(self) -> "BOPDS_IndexRange const &":
        return _BOPDS.BOPDS_VectorOfIndexRange_Last(self)

    def ChangeLast(self) -> "BOPDS_IndexRange &":
        return _BOPDS.BOPDS_VectorOfIndexRange_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_IndexRange &":
        return _BOPDS.BOPDS_VectorOfIndexRange___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_IndexRange &":
        return _BOPDS.BOPDS_VectorOfIndexRange_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_IndexRange") -> "BOPDS_IndexRange &":
        return _BOPDS.BOPDS_VectorOfIndexRange_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfIndexRange in _BOPDS:
_BOPDS.BOPDS_VectorOfIndexRange_swigregister(BOPDS_VectorOfIndexRange)

class BOPDS_VectorOfInterfEE(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_Vector< BOPDS_InterfEE >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfEE_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfEE >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfEE_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfEE >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfEE_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfEE >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfEE_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfEE_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfEE(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfEE

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEE_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEE_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEE_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEE_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfEE_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfEE_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfEE") -> "NCollection_Vector< BOPDS_InterfEE > &":
        return _BOPDS.BOPDS_VectorOfInterfEE_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfEE") -> "BOPDS_InterfEE &":
        return _BOPDS.BOPDS_VectorOfInterfEE_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfEE &":
        return _BOPDS.BOPDS_VectorOfInterfEE_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfEE const &":
        return _BOPDS.BOPDS_VectorOfInterfEE_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfEE const &":
        return _BOPDS.BOPDS_VectorOfInterfEE_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfEE &":
        return _BOPDS.BOPDS_VectorOfInterfEE_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfEE const &":
        return _BOPDS.BOPDS_VectorOfInterfEE_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfEE &":
        return _BOPDS.BOPDS_VectorOfInterfEE_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfEE &":
        return _BOPDS.BOPDS_VectorOfInterfEE___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfEE &":
        return _BOPDS.BOPDS_VectorOfInterfEE_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfEE") -> "BOPDS_InterfEE &":
        return _BOPDS.BOPDS_VectorOfInterfEE_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfEE in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfEE_swigregister(BOPDS_VectorOfInterfEE)

class BOPDS_VectorOfInterfEF(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_Vector< BOPDS_InterfEF >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfEF_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfEF >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfEF_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfEF >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfEF_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfEF >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfEF_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfEF_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfEF(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfEF

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEF_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEF_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEF_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEF_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfEF_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfEF_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfEF") -> "NCollection_Vector< BOPDS_InterfEF > &":
        return _BOPDS.BOPDS_VectorOfInterfEF_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfEF") -> "BOPDS_InterfEF &":
        return _BOPDS.BOPDS_VectorOfInterfEF_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfEF &":
        return _BOPDS.BOPDS_VectorOfInterfEF_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfEF const &":
        return _BOPDS.BOPDS_VectorOfInterfEF_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfEF const &":
        return _BOPDS.BOPDS_VectorOfInterfEF_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfEF &":
        return _BOPDS.BOPDS_VectorOfInterfEF_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfEF const &":
        return _BOPDS.BOPDS_VectorOfInterfEF_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfEF &":
        return _BOPDS.BOPDS_VectorOfInterfEF_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfEF &":
        return _BOPDS.BOPDS_VectorOfInterfEF___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfEF &":
        return _BOPDS.BOPDS_VectorOfInterfEF_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfEF") -> "BOPDS_InterfEF &":
        return _BOPDS.BOPDS_VectorOfInterfEF_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfEF in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfEF_swigregister(BOPDS_VectorOfInterfEF)

class BOPDS_VectorOfInterfEZ(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_Vector< BOPDS_InterfEZ >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfEZ_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfEZ >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfEZ_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfEZ >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfEZ_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfEZ >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfEZ_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfEZ_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfEZ(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfEZ

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfEZ_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfEZ") -> "NCollection_Vector< BOPDS_InterfEZ > &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfEZ") -> "BOPDS_InterfEZ &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfEZ &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfEZ const &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfEZ const &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfEZ &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfEZ const &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfEZ &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfEZ &":
        return _BOPDS.BOPDS_VectorOfInterfEZ___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfEZ &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfEZ") -> "BOPDS_InterfEZ &":
        return _BOPDS.BOPDS_VectorOfInterfEZ_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfEZ in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfEZ_swigregister(BOPDS_VectorOfInterfEZ)

class BOPDS_VectorOfInterfFF(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_Vector< BOPDS_InterfFF >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfFF_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfFF >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfFF_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfFF >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfFF_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfFF >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfFF_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfFF_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfFF(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfFF

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfFF_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfFF_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfFF_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfFF_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfFF_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfFF_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfFF") -> "NCollection_Vector< BOPDS_InterfFF > &":
        return _BOPDS.BOPDS_VectorOfInterfFF_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfFF") -> "BOPDS_InterfFF &":
        return _BOPDS.BOPDS_VectorOfInterfFF_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfFF &":
        return _BOPDS.BOPDS_VectorOfInterfFF_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfFF const &":
        return _BOPDS.BOPDS_VectorOfInterfFF_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfFF const &":
        return _BOPDS.BOPDS_VectorOfInterfFF_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfFF &":
        return _BOPDS.BOPDS_VectorOfInterfFF_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfFF const &":
        return _BOPDS.BOPDS_VectorOfInterfFF_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfFF &":
        return _BOPDS.BOPDS_VectorOfInterfFF_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfFF &":
        return _BOPDS.BOPDS_VectorOfInterfFF___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfFF &":
        return _BOPDS.BOPDS_VectorOfInterfFF_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfFF") -> "BOPDS_InterfFF &":
        return _BOPDS.BOPDS_VectorOfInterfFF_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfFF in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfFF_swigregister(BOPDS_VectorOfInterfFF)

class BOPDS_VectorOfInterfFZ(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_Vector< BOPDS_InterfFZ >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfFZ_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfFZ >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfFZ_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfFZ >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfFZ_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfFZ >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfFZ_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfFZ_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfFZ(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfFZ

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfFZ_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfFZ") -> "NCollection_Vector< BOPDS_InterfFZ > &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfFZ") -> "BOPDS_InterfFZ &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfFZ &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfFZ const &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfFZ const &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfFZ &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfFZ const &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfFZ &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfFZ &":
        return _BOPDS.BOPDS_VectorOfInterfFZ___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfFZ &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfFZ") -> "BOPDS_InterfFZ &":
        return _BOPDS.BOPDS_VectorOfInterfFZ_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfFZ in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfFZ_swigregister(BOPDS_VectorOfInterfFZ)

class BOPDS_VectorOfInterfVE(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_Vector< BOPDS_InterfVE >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfVE_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfVE >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfVE_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfVE >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfVE_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfVE >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfVE_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfVE_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfVE(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfVE

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVE_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVE_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVE_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVE_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfVE_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfVE_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfVE") -> "NCollection_Vector< BOPDS_InterfVE > &":
        return _BOPDS.BOPDS_VectorOfInterfVE_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfVE") -> "BOPDS_InterfVE &":
        return _BOPDS.BOPDS_VectorOfInterfVE_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfVE &":
        return _BOPDS.BOPDS_VectorOfInterfVE_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfVE const &":
        return _BOPDS.BOPDS_VectorOfInterfVE_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfVE const &":
        return _BOPDS.BOPDS_VectorOfInterfVE_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfVE &":
        return _BOPDS.BOPDS_VectorOfInterfVE_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfVE const &":
        return _BOPDS.BOPDS_VectorOfInterfVE_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfVE &":
        return _BOPDS.BOPDS_VectorOfInterfVE_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfVE &":
        return _BOPDS.BOPDS_VectorOfInterfVE___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfVE &":
        return _BOPDS.BOPDS_VectorOfInterfVE_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfVE") -> "BOPDS_InterfVE &":
        return _BOPDS.BOPDS_VectorOfInterfVE_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfVE in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfVE_swigregister(BOPDS_VectorOfInterfVE)

class BOPDS_VectorOfInterfVF(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_Vector< BOPDS_InterfVF >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfVF_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfVF >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfVF_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfVF >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfVF_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfVF >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfVF_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfVF_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfVF(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfVF

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVF_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVF_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVF_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVF_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfVF_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfVF_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfVF") -> "NCollection_Vector< BOPDS_InterfVF > &":
        return _BOPDS.BOPDS_VectorOfInterfVF_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfVF") -> "BOPDS_InterfVF &":
        return _BOPDS.BOPDS_VectorOfInterfVF_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfVF &":
        return _BOPDS.BOPDS_VectorOfInterfVF_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfVF const &":
        return _BOPDS.BOPDS_VectorOfInterfVF_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfVF const &":
        return _BOPDS.BOPDS_VectorOfInterfVF_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfVF &":
        return _BOPDS.BOPDS_VectorOfInterfVF_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfVF const &":
        return _BOPDS.BOPDS_VectorOfInterfVF_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfVF &":
        return _BOPDS.BOPDS_VectorOfInterfVF_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfVF &":
        return _BOPDS.BOPDS_VectorOfInterfVF___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfVF &":
        return _BOPDS.BOPDS_VectorOfInterfVF_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfVF") -> "BOPDS_InterfVF &":
        return _BOPDS.BOPDS_VectorOfInterfVF_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfVF in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfVF_swigregister(BOPDS_VectorOfInterfVF)

class BOPDS_VectorOfInterfVV(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_Vector< BOPDS_InterfVV >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfVV_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfVV >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfVV_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfVV >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfVV_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfVV >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfVV_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfVV_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfVV(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfVV

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVV_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVV_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVV_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVV_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfVV_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfVV_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfVV") -> "NCollection_Vector< BOPDS_InterfVV > &":
        return _BOPDS.BOPDS_VectorOfInterfVV_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfVV") -> "BOPDS_InterfVV &":
        return _BOPDS.BOPDS_VectorOfInterfVV_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfVV &":
        return _BOPDS.BOPDS_VectorOfInterfVV_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfVV const &":
        return _BOPDS.BOPDS_VectorOfInterfVV_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfVV const &":
        return _BOPDS.BOPDS_VectorOfInterfVV_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfVV &":
        return _BOPDS.BOPDS_VectorOfInterfVV_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfVV const &":
        return _BOPDS.BOPDS_VectorOfInterfVV_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfVV &":
        return _BOPDS.BOPDS_VectorOfInterfVV_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfVV &":
        return _BOPDS.BOPDS_VectorOfInterfVV___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfVV &":
        return _BOPDS.BOPDS_VectorOfInterfVV_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfVV") -> "BOPDS_InterfVV &":
        return _BOPDS.BOPDS_VectorOfInterfVV_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfVV in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfVV_swigregister(BOPDS_VectorOfInterfVV)

class BOPDS_VectorOfInterfVZ(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_Vector< BOPDS_InterfVZ >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfVZ_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfVZ >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfVZ_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfVZ >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfVZ_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfVZ >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfVZ_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfVZ_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfVZ(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfVZ

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfVZ_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfVZ") -> "NCollection_Vector< BOPDS_InterfVZ > &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfVZ") -> "BOPDS_InterfVZ &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfVZ &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfVZ const &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfVZ const &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfVZ &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfVZ const &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfVZ &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfVZ &":
        return _BOPDS.BOPDS_VectorOfInterfVZ___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfVZ &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfVZ") -> "BOPDS_InterfVZ &":
        return _BOPDS.BOPDS_VectorOfInterfVZ_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfVZ in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfVZ_swigregister(BOPDS_VectorOfInterfVZ)

class BOPDS_VectorOfInterfZZ(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_Vector< BOPDS_InterfZZ >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfZZ_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_InterfZZ >::iterator":
        return _BOPDS.BOPDS_VectorOfInterfZZ_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_InterfZZ >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfZZ_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_InterfZZ >::const_iterator":
        return _BOPDS.BOPDS_VectorOfInterfZZ_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfInterfZZ_swiginit(self, _BOPDS.new_BOPDS_VectorOfInterfZZ(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfInterfZZ

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfInterfZZ_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfInterfZZ") -> "NCollection_Vector< BOPDS_InterfZZ > &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Set(self, theOther)

    def Append(self, theValue: "BOPDS_InterfZZ") -> "BOPDS_InterfZZ &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Append(self, theValue)

    def Appended(self) -> "BOPDS_InterfZZ &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfZZ const &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Value(self, theIndex)

    def First(self) -> "BOPDS_InterfZZ const &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_First(self)

    def ChangeFirst(self) -> "BOPDS_InterfZZ &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_ChangeFirst(self)

    def Last(self) -> "BOPDS_InterfZZ const &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_Last(self)

    def ChangeLast(self) -> "BOPDS_InterfZZ &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_InterfZZ &":
        return _BOPDS.BOPDS_VectorOfInterfZZ___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_InterfZZ &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_InterfZZ") -> "BOPDS_InterfZZ &":
        return _BOPDS.BOPDS_VectorOfInterfZZ_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfInterfZZ in _BOPDS:
_BOPDS.BOPDS_VectorOfInterfZZ_swigregister(BOPDS_VectorOfInterfZZ)

class BOPDS_VectorOfListOfPaveBlock(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_Vector< BOPDS_ListOfPaveBlock >::iterator":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_ListOfPaveBlock >::iterator":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_ListOfPaveBlock >::const_iterator":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_ListOfPaveBlock >::const_iterator":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfListOfPaveBlock_swiginit(self, _BOPDS.new_BOPDS_VectorOfListOfPaveBlock(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfListOfPaveBlock

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfListOfPaveBlock") -> "NCollection_Vector< BOPDS_ListOfPaveBlock > &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Set(self, theOther)

    def Append(self, theValue: "BOPDS_ListOfPaveBlock") -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Append(self, theValue)

    def Appended(self) -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_ListOfPaveBlock const &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Value(self, theIndex)

    def First(self) -> "BOPDS_ListOfPaveBlock const &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_First(self)

    def ChangeFirst(self) -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_ChangeFirst(self)

    def Last(self) -> "BOPDS_ListOfPaveBlock const &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_Last(self)

    def ChangeLast(self) -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_ListOfPaveBlock") -> "BOPDS_ListOfPaveBlock &":
        return _BOPDS.BOPDS_VectorOfListOfPaveBlock_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfListOfPaveBlock in _BOPDS:
_BOPDS.BOPDS_VectorOfListOfPaveBlock_swigregister(BOPDS_VectorOfListOfPaveBlock)

class BOPDS_VectorOfPair(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_Vector< BOPDS_Pair >::iterator":
        return _BOPDS.BOPDS_VectorOfPair_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_Pair >::iterator":
        return _BOPDS.BOPDS_VectorOfPair_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_Pair >::const_iterator":
        return _BOPDS.BOPDS_VectorOfPair_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_Pair >::const_iterator":
        return _BOPDS.BOPDS_VectorOfPair_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfPair_swiginit(self, _BOPDS.new_BOPDS_VectorOfPair(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfPair

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPair_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPair_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPair_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPair_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfPair_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfPair_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfPair") -> "NCollection_Vector< BOPDS_Pair > &":
        return _BOPDS.BOPDS_VectorOfPair_Set(self, theOther)

    def Append(self, theValue: "BOPDS_Pair") -> "BOPDS_Pair &":
        return _BOPDS.BOPDS_VectorOfPair_Append(self, theValue)

    def Appended(self) -> "BOPDS_Pair &":
        return _BOPDS.BOPDS_VectorOfPair_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_Pair const &":
        return _BOPDS.BOPDS_VectorOfPair_Value(self, theIndex)

    def First(self) -> "BOPDS_Pair const &":
        return _BOPDS.BOPDS_VectorOfPair_First(self)

    def ChangeFirst(self) -> "BOPDS_Pair &":
        return _BOPDS.BOPDS_VectorOfPair_ChangeFirst(self)

    def Last(self) -> "BOPDS_Pair const &":
        return _BOPDS.BOPDS_VectorOfPair_Last(self)

    def ChangeLast(self) -> "BOPDS_Pair &":
        return _BOPDS.BOPDS_VectorOfPair_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_Pair &":
        return _BOPDS.BOPDS_VectorOfPair___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_Pair &":
        return _BOPDS.BOPDS_VectorOfPair_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_Pair") -> "BOPDS_Pair &":
        return _BOPDS.BOPDS_VectorOfPair_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfPair in _BOPDS:
_BOPDS.BOPDS_VectorOfPair_swigregister(BOPDS_VectorOfPair)

class BOPDS_VectorOfPave(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_Array1< BOPDS_Pave >::iterator":
        return _BOPDS.BOPDS_VectorOfPave_begin(self)

    def end(self) -> "NCollection_Array1< BOPDS_Pave >::iterator":
        return _BOPDS.BOPDS_VectorOfPave_end(self)

    def cbegin(self) -> "NCollection_Array1< BOPDS_Pave >::const_iterator":
        return _BOPDS.BOPDS_VectorOfPave_cbegin(self)

    def cend(self) -> "NCollection_Array1< BOPDS_Pave >::const_iterator":
        return _BOPDS.BOPDS_VectorOfPave_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfPave_swiginit(self, _BOPDS.new_BOPDS_VectorOfPave(*args))

    def Init(self, theValue: "BOPDS_Pave") -> "void":
        return _BOPDS.BOPDS_VectorOfPave_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPave_Size(self)

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPave_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfPave_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPave_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPave_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfPave_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfPave_IsAllocated(self)

    def Assign(self, theOther: "BOPDS_VectorOfPave") -> "NCollection_Array1< BOPDS_Pave > &":
        return _BOPDS.BOPDS_VectorOfPave_Assign(self, theOther)

    def Move(self, theOther: "BOPDS_VectorOfPave") -> "NCollection_Array1< BOPDS_Pave > &":
        return _BOPDS.BOPDS_VectorOfPave_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< BOPDS_Pave > &":
        return _BOPDS.BOPDS_VectorOfPave_Set(self, *args)

    def First(self) -> "BOPDS_Pave const &":
        return _BOPDS.BOPDS_VectorOfPave_First(self)

    def ChangeFirst(self) -> "BOPDS_Pave &":
        return _BOPDS.BOPDS_VectorOfPave_ChangeFirst(self)

    def Last(self) -> "BOPDS_Pave const &":
        return _BOPDS.BOPDS_VectorOfPave_Last(self)

    def ChangeLast(self) -> "BOPDS_Pave &":
        return _BOPDS.BOPDS_VectorOfPave_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_Pave const &":
        return _BOPDS.BOPDS_VectorOfPave_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_Pave &":
        return _BOPDS.BOPDS_VectorOfPave_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "BOPDS_Pave &":
        return _BOPDS.BOPDS_VectorOfPave___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "BOPDS_Pave") -> "void":
        return _BOPDS.BOPDS_VectorOfPave_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _BOPDS.BOPDS_VectorOfPave_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfPave

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

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

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register BOPDS_VectorOfPave in _BOPDS:
_BOPDS.BOPDS_VectorOfPave_swigregister(BOPDS_VectorOfPave)

class BOPDS_VectorOfPoint(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_Vector< BOPDS_Point >::iterator":
        return _BOPDS.BOPDS_VectorOfPoint_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_Point >::iterator":
        return _BOPDS.BOPDS_VectorOfPoint_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_Point >::const_iterator":
        return _BOPDS.BOPDS_VectorOfPoint_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_Point >::const_iterator":
        return _BOPDS.BOPDS_VectorOfPoint_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfPoint_swiginit(self, _BOPDS.new_BOPDS_VectorOfPoint(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfPoint

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPoint_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPoint_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPoint_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfPoint_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfPoint_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfPoint_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfPoint") -> "NCollection_Vector< BOPDS_Point > &":
        return _BOPDS.BOPDS_VectorOfPoint_Set(self, theOther)

    def Append(self, theValue: "BOPDS_Point") -> "BOPDS_Point &":
        return _BOPDS.BOPDS_VectorOfPoint_Append(self, theValue)

    def Appended(self) -> "BOPDS_Point &":
        return _BOPDS.BOPDS_VectorOfPoint_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_Point const &":
        return _BOPDS.BOPDS_VectorOfPoint_Value(self, theIndex)

    def First(self) -> "BOPDS_Point const &":
        return _BOPDS.BOPDS_VectorOfPoint_First(self)

    def ChangeFirst(self) -> "BOPDS_Point &":
        return _BOPDS.BOPDS_VectorOfPoint_ChangeFirst(self)

    def Last(self) -> "BOPDS_Point const &":
        return _BOPDS.BOPDS_VectorOfPoint_Last(self)

    def ChangeLast(self) -> "BOPDS_Point &":
        return _BOPDS.BOPDS_VectorOfPoint_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_Point &":
        return _BOPDS.BOPDS_VectorOfPoint___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_Point &":
        return _BOPDS.BOPDS_VectorOfPoint_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_Point") -> "BOPDS_Point &":
        return _BOPDS.BOPDS_VectorOfPoint_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfPoint in _BOPDS:
_BOPDS.BOPDS_VectorOfPoint_swigregister(BOPDS_VectorOfPoint)

class BOPDS_VectorOfShapeInfo(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_Vector< BOPDS_ShapeInfo >::iterator":
        return _BOPDS.BOPDS_VectorOfShapeInfo_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_ShapeInfo >::iterator":
        return _BOPDS.BOPDS_VectorOfShapeInfo_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_ShapeInfo >::const_iterator":
        return _BOPDS.BOPDS_VectorOfShapeInfo_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_ShapeInfo >::const_iterator":
        return _BOPDS.BOPDS_VectorOfShapeInfo_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfShapeInfo_swiginit(self, _BOPDS.new_BOPDS_VectorOfShapeInfo(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfShapeInfo

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfShapeInfo_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfShapeInfo") -> "NCollection_Vector< BOPDS_ShapeInfo > &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Set(self, theOther)

    def Append(self, theValue: "BOPDS_ShapeInfo") -> "BOPDS_ShapeInfo &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Append(self, theValue)

    def Appended(self) -> "BOPDS_ShapeInfo &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_ShapeInfo const &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Value(self, theIndex)

    def First(self) -> "BOPDS_ShapeInfo const &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_First(self)

    def ChangeFirst(self) -> "BOPDS_ShapeInfo &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_ChangeFirst(self)

    def Last(self) -> "BOPDS_ShapeInfo const &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_Last(self)

    def ChangeLast(self) -> "BOPDS_ShapeInfo &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_ShapeInfo &":
        return _BOPDS.BOPDS_VectorOfShapeInfo___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_ShapeInfo &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_ShapeInfo") -> "BOPDS_ShapeInfo &":
        return _BOPDS.BOPDS_VectorOfShapeInfo_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfShapeInfo in _BOPDS:
_BOPDS.BOPDS_VectorOfShapeInfo_swigregister(BOPDS_VectorOfShapeInfo)

class BOPDS_VectorOfVectorOfPair(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_Vector< BOPDS_VectorOfPair >::iterator":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_begin(self)

    def end(self) -> "NCollection_Vector< BOPDS_VectorOfPair >::iterator":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_end(self)

    def cbegin(self) -> "NCollection_Vector< BOPDS_VectorOfPair >::const_iterator":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_cbegin(self)

    def cend(self) -> "NCollection_Vector< BOPDS_VectorOfPair >::const_iterator":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_cend(self)

    def __init__(self, *args):
        _BOPDS.BOPDS_VectorOfVectorOfPair_swiginit(self, _BOPDS.new_BOPDS_VectorOfVectorOfPair(*args))
    __swig_destroy__ = _BOPDS.delete_BOPDS_VectorOfVectorOfPair

    def Length(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Length(self)

    def Size(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Size(self)

    def Lower(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_IsEmpty(self)

    def Assign(self, *args) -> "void":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Assign(self, *args)

    def Set(self, theOther: "BOPDS_VectorOfVectorOfPair") -> "NCollection_Vector< BOPDS_VectorOfPair > &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Set(self, theOther)

    def Append(self, theValue: "BOPDS_VectorOfPair") -> "BOPDS_VectorOfPair &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Append(self, theValue)

    def Appended(self) -> "BOPDS_VectorOfPair &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Appended(self)

    def Value(self, theIndex: "Standard_Integer const") -> "BOPDS_VectorOfPair const &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Value(self, theIndex)

    def First(self) -> "BOPDS_VectorOfPair const &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_First(self)

    def ChangeFirst(self) -> "BOPDS_VectorOfPair &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_ChangeFirst(self)

    def Last(self) -> "BOPDS_VectorOfPair const &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_Last(self)

    def ChangeLast(self) -> "BOPDS_VectorOfPair &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_ChangeLast(self)

    def __call__(self, *args) -> "BOPDS_VectorOfPair &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair___call__(self, *args)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "BOPDS_VectorOfPair &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_ChangeValue(self, theIndex)

    def SetValue(self, theIndex: "Standard_Integer const", theValue: "BOPDS_VectorOfPair") -> "BOPDS_VectorOfPair &":
        return _BOPDS.BOPDS_VectorOfVectorOfPair_SetValue(self, theIndex, theValue)

# Register BOPDS_VectorOfVectorOfPair in _BOPDS:
_BOPDS.BOPDS_VectorOfVectorOfPair_swigregister(BOPDS_VectorOfVectorOfPair)

class BOPDS_CommonBlock(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"""
        Empty contructor.

        Returns
        -------
        None
        Contructor <theallocator> - the allocator to manage the memory.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_CommonBlock_swiginit(self, _BOPDS.new_BOPDS_CommonBlock(*args))

    def AddFace(self, *args) -> "void":
        r"""
        Modifier adds the index of the face <af> to the list of indices of faces of the common block.

        Parameters
        ----------
        aF: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CommonBlock_AddFace(self, *args)

    def AddPaveBlock(self, *args) -> "void":
        r"""
        Modifier adds the pave block <apb> to the list of pave blocks of the common block.

        Parameters
        ----------
        aPB: BOPDS_PaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CommonBlock_AddPaveBlock(self, *args)

    def AppendFaces(self, *args) -> "void":
        r"""
        Modifier appends the list of indices of faces <alf> to the list of indices of faces of the common block (the input list is emptied).

        Parameters
        ----------
        aLF: TColStd_ListOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CommonBlock_AppendFaces(self, *args)

    def Contains(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the common block contains a pave block that is equal to <thepb>.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        bool
        Query returns true if the common block contains the face with index equal to <thef>.

        Parameters
        ----------
        theF: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_CommonBlock_Contains(self, *args)

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

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CommonBlock_Dump(self, *args)

    def Edge(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the index of the edge of all pave blocks of the common block.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_CommonBlock_Edge(self, *args)

    def Faces(self, *args) -> "TColStd_ListOfInteger const &":
        r"""
        Selector returns the list of indices of faces of the common block.

        Returns
        -------
        TColStd_ListOfInteger

        """
        return _BOPDS.BOPDS_CommonBlock_Faces(self, *args)

    def IsPaveBlockOnEdge(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the common block contains a pave block that belongs to the edge with index <theix>.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_CommonBlock_IsPaveBlockOnEdge(self, *args)

    def IsPaveBlockOnFace(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the common block contains a pave block that belongs to the face with index <theix>.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_CommonBlock_IsPaveBlockOnFace(self, *args)

    def PaveBlock1(self, *args) -> "opencascade::handle< BOPDS_PaveBlock > const &":
        r"""
        Selector returns the first pave block of the common block.

        Returns
        -------
        opencascade::handle<BOPDS_PaveBlock>

        """
        return _BOPDS.BOPDS_CommonBlock_PaveBlock1(self, *args)

    def PaveBlockOnEdge(self, *args) -> "opencascade::handle< BOPDS_PaveBlock > &":
        r"""
        Selector returns the pave block that belongs to the edge with index <theix>.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        opencascade::handle<BOPDS_PaveBlock>

        """
        return _BOPDS.BOPDS_CommonBlock_PaveBlockOnEdge(self, *args)

    def PaveBlocks(self, *args) -> "BOPDS_ListOfPaveBlock const &":
        r"""
        Selector returns the list of pave blocks of the common block.

        Returns
        -------
        BOPDS_ListOfPaveBlock

        """
        return _BOPDS.BOPDS_CommonBlock_PaveBlocks(self, *args)

    def SetEdge(self, *args) -> "void":
        r"""
        Modifier assign the index <theedge> as the edge index to all pave blocks of the common block.

        Parameters
        ----------
        theEdge: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CommonBlock_SetEdge(self, *args)

    def SetFaces(self, *args) -> "void":
        r"""
        Modifier sets the list of indices of faces <alf> of the common block.

        Parameters
        ----------
        aLF: TColStd_ListOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CommonBlock_SetFaces(self, *args)

    def SetPaveBlocks(self, *args) -> "void":
        r"""
        Modifier sets the list of pave blocks for the common block.

        Parameters
        ----------
        aLPB: BOPDS_ListOfPaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CommonBlock_SetPaveBlocks(self, *args)

    def SetRealPaveBlock(self, *args) -> "void":
        r"""
        Moves the pave blocks in the list to make the given pave block to be the first. it will be representative for the whole group.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CommonBlock_SetRealPaveBlock(self, *args)

    def SetTolerance(self, *args) -> "void":
        r"""
        Sets the tolerance for the common block.

        Parameters
        ----------
        theTol: float

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CommonBlock_SetTolerance(self, *args)

    def Tolerance(self, *args) -> "Standard_Real":
        r"""
        Return the tolerance of common block.

        Returns
        -------
        float

        """
        return _BOPDS.BOPDS_CommonBlock_Tolerance(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_CommonBlock

# Register BOPDS_CommonBlock in _BOPDS:
_BOPDS.BOPDS_CommonBlock_swigregister(BOPDS_CommonBlock)

class BOPDS_CoupleOfPaveBlocks(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param thepb1 * first pave block * @param thepb2 * secondt pave block */.

        Parameters
        ----------
        thePB1: BOPDS_PaveBlock
        thePB2: BOPDS_PaveBlock

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_CoupleOfPaveBlocks_swiginit(self, _BOPDS.new_BOPDS_CoupleOfPaveBlocks(*args))

    def Index(self, *args) -> "Standard_Integer":
        r"""
        /** * returns the index * returns * index */.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_Index(self, *args)

    def IndexInterf(self, *args) -> "Standard_Integer":
        r"""
        /** * returns the index of an interference * returns * index of an interference */.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_IndexInterf(self, *args)

    def PaveBlock1(self, *args) -> "opencascade::handle< BOPDS_PaveBlock > const &":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<BOPDS_PaveBlock>

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_PaveBlock1(self, *args)

    def PaveBlock2(self, *args) -> "opencascade::handle< BOPDS_PaveBlock > const &":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<BOPDS_PaveBlock>

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_PaveBlock2(self, *args)

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

        Parameters
        ----------
        thePB1: BOPDS_PaveBlock
        thePB2: BOPDS_PaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_PaveBlocks(self, *args)

    def SetIndex(self, *args) -> "void":
        r"""
        /** * sets an index * @param theindex * index */.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_SetIndex(self, *args)

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

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_SetIndexInterf(self, *args)

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

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_SetPaveBlock1(self, *args)

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

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_SetPaveBlock2(self, *args)

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

        Parameters
        ----------
        thePB1: BOPDS_PaveBlock
        thePB2: BOPDS_PaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_SetPaveBlocks(self, *args)

    def SetTolerance(self, *args) -> "void":
        r"""
        /** * sets the tolerance associated with this couple */.

        Parameters
        ----------
        theTol: float

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_SetTolerance(self, *args)

    def Tolerance(self, *args) -> "Standard_Real":
        r"""
        /** * returns the tolerance associated with this couple */.

        Returns
        -------
        float

        """
        return _BOPDS.BOPDS_CoupleOfPaveBlocks_Tolerance(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_CoupleOfPaveBlocks

# Register BOPDS_CoupleOfPaveBlocks in _BOPDS:
_BOPDS.BOPDS_CoupleOfPaveBlocks_swigregister(BOPDS_CoupleOfPaveBlocks)

class BOPDS_Curve(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"""
        Empty contructor.

        Returns
        -------
        None
        Contructor <theallocator> - the allocator to manage the memory.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_Curve_swiginit(self, _BOPDS.new_BOPDS_Curve(*args))

    def Box(self, *args) -> "Bnd_Box const &":
        r"""
        Selector returns the bounding box of the curve.

        Returns
        -------
        Bnd_Box

        """
        return _BOPDS.BOPDS_Curve_Box(self, *args)

    def ChangeBox(self, *args) -> "Bnd_Box &":
        r"""
        Selector/modifier returns the bounding box of the curve.

        Returns
        -------
        Bnd_Box

        """
        return _BOPDS.BOPDS_Curve_ChangeBox(self, *args)

    def ChangePaveBlock1(self, *args) -> "opencascade::handle< BOPDS_PaveBlock > &":
        r"""
        Selector/modifier returns initial pave block of the curve.

        Returns
        -------
        opencascade::handle<BOPDS_PaveBlock>

        """
        return _BOPDS.BOPDS_Curve_ChangePaveBlock1(self, *args)

    def ChangePaveBlocks(self, *args) -> "BOPDS_ListOfPaveBlock &":
        r"""
        Selector/modifier returns the list of pave blocks of the curve.

        Returns
        -------
        BOPDS_ListOfPaveBlock

        """
        return _BOPDS.BOPDS_Curve_ChangePaveBlocks(self, *args)

    def ChangeTechnoVertices(self, *args) -> "TColStd_ListOfInteger &":
        r"""
        Selector/modifier returns list of indices of technologic vertices of the curve.

        Returns
        -------
        TColStd_ListOfInteger

        """
        return _BOPDS.BOPDS_Curve_ChangeTechnoVertices(self, *args)

    def Curve(self, *args) -> "IntTools_Curve const &":
        r"""
        Selector returns the curve.

        Returns
        -------
        IntTools_Curve

        """
        return _BOPDS.BOPDS_Curve_Curve(self, *args)

    def HasEdge(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if at least one pave block of the curve has edge.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_Curve_HasEdge(self, *args)

    def InitPaveBlock1(self, *args) -> "void":
        r"""
        Creates initial pave block of the curve.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Curve_InitPaveBlock1(self, *args)

    def PaveBlocks(self, *args) -> "BOPDS_ListOfPaveBlock const &":
        r"""
        Selector returns the list of pave blocks of the curve.

        Returns
        -------
        BOPDS_ListOfPaveBlock

        """
        return _BOPDS.BOPDS_Curve_PaveBlocks(self, *args)

    def SetBox(self, *args) -> "void":
        r"""
        Modifier sets the bounding box <thebox> of the curve.

        Parameters
        ----------
        theBox: Bnd_Box

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Curve_SetBox(self, *args)

    def SetCurve(self, *args) -> "void":
        r"""
        Modifier sets the curve <thec>.

        Parameters
        ----------
        theC: IntTools_Curve

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Curve_SetCurve(self, *args)

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

        Parameters
        ----------
        theLPB: BOPDS_ListOfPaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Curve_SetPaveBlocks(self, *args)

    def SetTolerance(self, *args) -> "void":
        r"""
        Sets the tolerance for the curve.

        Parameters
        ----------
        theTol: float

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Curve_SetTolerance(self, *args)

    def TangentialTolerance(self, *args) -> "Standard_Real":
        r"""
        Returns the tangential tolerance of the curve.

        Returns
        -------
        float

        """
        return _BOPDS.BOPDS_Curve_TangentialTolerance(self, *args)

    def TechnoVertices(self, *args) -> "TColStd_ListOfInteger const &":
        r"""
        Selector returns list of indices of technologic vertices of the curve.

        Returns
        -------
        TColStd_ListOfInteger

        """
        return _BOPDS.BOPDS_Curve_TechnoVertices(self, *args)

    def Tolerance(self, *args) -> "Standard_Real":
        r"""
        Returns the tolerance of the curve.

        Returns
        -------
        float

        """
        return _BOPDS.BOPDS_Curve_Tolerance(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_Curve

# Register BOPDS_Curve in _BOPDS:
_BOPDS.BOPDS_Curve_swigregister(BOPDS_Curve)

class BOPDS_DS(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"""
        Empty contructor.

        Returns
        -------
        None
        Contructor theallocator - the allocator to manage the memory.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_DS_swiginit(self, _BOPDS.new_BOPDS_DS(*args))

    def AddInterf(self, *args) -> "Standard_Boolean":
        r"""
        Modifier adds the information about an interference between shapes with indices thei1, thei2 to the summary table of interferences.

        Parameters
        ----------
        theI1: int
        theI2: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_AddInterf(self, *args)

    def AddShapeSD(self, *args) -> "void":
        r"""
        Modifier adds the information about same domain shapes with indices theindex, theindexsd.

        Parameters
        ----------
        theIndex: int
        theIndexSD: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_AddShapeSD(self, *args)

    def Allocator(self, *args) -> "opencascade::handle< NCollection_BaseAllocator > const &":
        r"""
        Selector.

        Returns
        -------
        opencascade::handle<NCollection_BaseAllocator>

        """
        return _BOPDS.BOPDS_DS_Allocator(self, *args)

    def AloneVertices(self, *args) -> "void":
        r"""
        Selector returns the indices of alone vertices for the face with index theindex.

        Parameters
        ----------
        theF: int
        theLI: TColStd_ListOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_AloneVertices(self, *args)

    def Append(self, *args) -> "Standard_Integer":
        r"""
        Modifier appends the information about the shape [thesi] to the data structure returns the index of thesi in the data structure.

        Parameters
        ----------
        theSI: BOPDS_ShapeInfo

        Returns
        -------
        int
        Modifier appends the default information about the shape [thes] to the data structure returns the index of thes in the data structure.

        Parameters
        ----------
        theS: TopoDS_Shape

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_DS_Append(self, *args)

    def Arguments(self, *args) -> "TopTools_ListOfShape const &":
        r"""
        Selector returns the arguments of an operation.

        Returns
        -------
        TopTools_ListOfShape

        """
        return _BOPDS.BOPDS_DS_Arguments(self, *args)

    def BuildBndBoxSolid(self, *args) -> "void":
        r"""
        Computes bounding box <thebox> for the solid with ds-index <theindex>. the flag <thecheckinverted> enables/disables the check of the solid for inverted status. by default the solids will be checked.

        Parameters
        ----------
        theIndex: int
        theBox: Bnd_Box
        theCheckInverted: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_BuildBndBoxSolid(self, *args)

    def ChangeFaceInfo(self, *args) -> "BOPDS_FaceInfo &":
        r"""
        Selector/modifier returns the state of face with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        BOPDS_FaceInfo

        """
        return _BOPDS.BOPDS_DS_ChangeFaceInfo(self, *args)

    def ChangePaveBlocks(self, *args) -> "BOPDS_ListOfPaveBlock &":
        r"""
        Selector/modifier returns the pave blocks for the shape with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        BOPDS_ListOfPaveBlock

        """
        return _BOPDS.BOPDS_DS_ChangePaveBlocks(self, *args)

    def ChangePaveBlocksPool(self, *args) -> "BOPDS_VectorOfListOfPaveBlock &":
        r"""
        Selector/modifier returns the information about pave blocks on source edges.

        Returns
        -------
        BOPDS_VectorOfListOfPaveBlock

        """
        return _BOPDS.BOPDS_DS_ChangePaveBlocksPool(self, *args)

    def ChangeShapeInfo(self, *args) -> "BOPDS_ShapeInfo &":
        r"""
        Selector/modifier returns the information about the shape with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        BOPDS_ShapeInfo

        """
        return _BOPDS.BOPDS_DS_ChangeShapeInfo(self, *args)

    def Clear(self, *args) -> "void":
        r"""
        Clears the contents.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_Clear(self, *args)

    def CommonBlock(self, *args) -> "opencascade::handle< BOPDS_CommonBlock >":
        r"""
        Selector returns the common block.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        opencascade::handle<BOPDS_CommonBlock>

        """
        return _BOPDS.BOPDS_DS_CommonBlock(self, *args)

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

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_Dump(self, *args)

    def FaceInfo(self, *args) -> "BOPDS_FaceInfo const &":
        r"""
        Selector returns the state of face with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        BOPDS_FaceInfo

        """
        return _BOPDS.BOPDS_DS_FaceInfo(self, *args)

    def FaceInfoIn(self, *args) -> "void":
        r"""
        Selector returns the state in [thempb,themvp] of face with index theindex.

        Parameters
        ----------
        theIndex: int
        theMPB: BOPDS_IndexedMapOfPaveBlock
        theMVP: TColStd_MapOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_FaceInfoIn(self, *args)

    def FaceInfoOn(self, *args) -> "void":
        r"""
        Selector returns the state on [thempb,themvp] of face with index theindex.

        Parameters
        ----------
        theIndex: int
        theMPB: BOPDS_IndexedMapOfPaveBlock
        theMVP: TColStd_MapOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_FaceInfoOn(self, *args)

    def FaceInfoPool(self, *args) -> "BOPDS_VectorOfFaceInfo const &":
        r"""
        Selector returns the information about state of faces.

        Returns
        -------
        BOPDS_VectorOfFaceInfo

        """
        return _BOPDS.BOPDS_DS_FaceInfoPool(self, *args)

    def HasFaceInfo(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the shape with index theindex has the information about state of face.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_HasFaceInfo(self, *args)

    def HasInterf(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the shape with index thei is interferred.

        Parameters
        ----------
        theI: int

        Returns
        -------
        bool
        Query returns true if the shapes with indices thei1, thei2 are interferred.

        Parameters
        ----------
        theI1: int
        theI2: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_HasInterf(self, *args)

    def HasInterfShapeSubShapes(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the shape with index thei1 is interfered with any sub-shape of the shape with index thei2 (theflag=true) all sub-shapes of the shape with index thei2 (theflag=false).

        Parameters
        ----------
        theI1: int
        theI2: int
        theFlag: bool,optional
        	default value is Standard_True

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_HasInterfShapeSubShapes(self, *args)

    def HasInterfSubShapes(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the shapes with indices thei1, thei2 have interferred sub-shapes.

        Parameters
        ----------
        theI1: int
        theI2: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_HasInterfSubShapes(self, *args)

    def HasPaveBlocks(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the shape with index theindex has the information about pave blocks.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_HasPaveBlocks(self, *args)

    def HasShapeSD(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the shape with index theindex has the same domain shape. in this case theindexsd will contain the index of same domain shape found //! interferences.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        theIndexSD: int

        """
        return _BOPDS.BOPDS_DS_HasShapeSD(self, *args)

    def Index(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the index of the shape thes.

        Parameters
        ----------
        theS: TopoDS_Shape

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_DS_Index(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Initializes the data structure for the arguments.

        Parameters
        ----------
        theFuzz: float,optional
        	default value is Precision::Confusion()

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_Init(self, *args)

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

        Parameters
        ----------
        theNV: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_InitPaveBlocksForVertex(self, *args)

    def InterfEE(self, *args) -> "BOPDS_VectorOfInterfEE &":
        r"""
        Selector/modifier returns the collection of interferences edge/edge.

        Returns
        -------
        BOPDS_VectorOfInterfEE

        """
        return _BOPDS.BOPDS_DS_InterfEE(self, *args)

    def InterfEF(self, *args) -> "BOPDS_VectorOfInterfEF &":
        r"""
        Selector/modifier returns the collection of interferences edge/face.

        Returns
        -------
        BOPDS_VectorOfInterfEF

        """
        return _BOPDS.BOPDS_DS_InterfEF(self, *args)

    def InterfEZ(self, *args) -> "BOPDS_VectorOfInterfEZ &":
        r"""
        Selector/modifier returns the collection of interferences edge/solid.

        Returns
        -------
        BOPDS_VectorOfInterfEZ

        """
        return _BOPDS.BOPDS_DS_InterfEZ(self, *args)

    def InterfFF(self, *args) -> "BOPDS_VectorOfInterfFF &":
        r"""
        Selector/modifier returns the collection of interferences face/face.

        Returns
        -------
        BOPDS_VectorOfInterfFF

        """
        return _BOPDS.BOPDS_DS_InterfFF(self, *args)

    def InterfFZ(self, *args) -> "BOPDS_VectorOfInterfFZ &":
        r"""
        Selector/modifier returns the collection of interferences face/solid.

        Returns
        -------
        BOPDS_VectorOfInterfFZ

        """
        return _BOPDS.BOPDS_DS_InterfFZ(self, *args)

    def InterfVE(self, *args) -> "BOPDS_VectorOfInterfVE &":
        r"""
        Selector/modifier returns the collection of interferences vertex/edge.

        Returns
        -------
        BOPDS_VectorOfInterfVE

        """
        return _BOPDS.BOPDS_DS_InterfVE(self, *args)

    def InterfVF(self, *args) -> "BOPDS_VectorOfInterfVF &":
        r"""
        Selector/modifier returns the collection of interferences vertex/face.

        Returns
        -------
        BOPDS_VectorOfInterfVF

        """
        return _BOPDS.BOPDS_DS_InterfVF(self, *args)

    def InterfVV(self, *args) -> "BOPDS_VectorOfInterfVV &":
        r"""
        Selector/modifier returns the collection of interferences vertex/vertex.

        Returns
        -------
        BOPDS_VectorOfInterfVV

        """
        return _BOPDS.BOPDS_DS_InterfVV(self, *args)

    def InterfVZ(self, *args) -> "BOPDS_VectorOfInterfVZ &":
        r"""
        Selector/modifier returns the collection of interferences vertex/solid.

        Returns
        -------
        BOPDS_VectorOfInterfVZ

        """
        return _BOPDS.BOPDS_DS_InterfVZ(self, *args)

    def InterfZZ(self, *args) -> "BOPDS_VectorOfInterfZZ &":
        r"""
        Selector/modifier returns the collection of interferences solid/solid.

        Returns
        -------
        BOPDS_VectorOfInterfZZ

        """
        return _BOPDS.BOPDS_DS_InterfZZ(self, *args)

    def Interferences(self, *args) -> "BOPDS_MapOfPair const &":
        r"""
        Selector returns the table of interferences //! debug.

        Returns
        -------
        BOPDS_MapOfPair

        """
        return _BOPDS.BOPDS_DS_Interferences(self, *args)

    def IsCommonBlock(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the pave block is common block.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_IsCommonBlock(self, *args)

    def IsCommonBlockOnEdge(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if common block contains more then one pave block.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_IsCommonBlockOnEdge(self, *args)

    def IsNewShape(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the shape of index 'i' is not the source shape/sub-shape.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_IsNewShape(self, *args)

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

        Parameters
        ----------
        theI1: int
        theI2: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_IsSubShape(self, *args)

    def IsValidShrunkData(self, *args) -> "Standard_Boolean":
        r"""
        Checks if the existing shrunk data of the pave block is still valid. the shrunk data may become invalid if e.g. the vertices of the pave block have been replaced with the new one with bigger tolerances, or the tolerances of the existing vertices have been increased.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_DS_IsValidShrunkData(self, *args)

    @staticmethod
    def NbInterfTypes(*args) -> "Standard_Integer":
        r"""
        Returns the number of types of the interferences.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_DS_NbInterfTypes(*args)

    def NbRanges(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the number of index ranges.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_DS_NbRanges(self, *args)

    def NbShapes(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the total number of shapes stored.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_DS_NbShapes(self, *args)

    def NbSourceShapes(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the total number of source shapes stored.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_DS_NbSourceShapes(self, *args)

    def PaveBlocks(self, *args) -> "BOPDS_ListOfPaveBlock const &":
        r"""
        Selector returns the pave blocks for the shape with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        BOPDS_ListOfPaveBlock

        """
        return _BOPDS.BOPDS_DS_PaveBlocks(self, *args)

    def PaveBlocksPool(self, *args) -> "BOPDS_VectorOfListOfPaveBlock const &":
        r"""
        Selector returns the information about pave blocks on source edges.

        Returns
        -------
        BOPDS_VectorOfListOfPaveBlock

        """
        return _BOPDS.BOPDS_DS_PaveBlocksPool(self, *args)

    def Paves(self, *args) -> "void":
        r"""
        Fills thelp with sorted paves of the shape with index theindex.

        Parameters
        ----------
        theIndex: int
        theLP: BOPDS_ListOfPave

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_Paves(self, *args)

    def Range(self, *args) -> "BOPDS_IndexRange const &":
        r"""
        Selector returns the index range 'i'.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        BOPDS_IndexRange

        """
        return _BOPDS.BOPDS_DS_Range(self, *args)

    def Rank(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the rank of the shape of index 'i'.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_DS_Rank(self, *args)

    def RealPaveBlock(self, *args) -> "opencascade::handle< BOPDS_PaveBlock >":
        r"""
        Selector returns the real first pave block.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        opencascade::handle<BOPDS_PaveBlock>

        """
        return _BOPDS.BOPDS_DS_RealPaveBlock(self, *args)

    def RefineFaceInfoIn(self, *args) -> "void":
        r"""
        Removes any pave block from list of having in state if it has also the state on.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_RefineFaceInfoIn(self, *args)

    def RefineFaceInfoOn(self, *args) -> "void":
        r"""
        Refine the state on for the all faces having state information //! ++.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_RefineFaceInfoOn(self, *args)

    def ReleasePaveBlocks(self, *args) -> "void":
        r"""
        Clears information about paveblocks for the untouched edges.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_ReleasePaveBlocks(self, *args)

    def SetArguments(self, *args) -> "void":
        r"""
        Modifier sets the arguments [thels] of an operation.

        Parameters
        ----------
        theLS: TopTools_ListOfShape

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_SetArguments(self, *args)

    def SetCommonBlock(self, *args) -> "void":
        r"""
        Modifier sets the common block <thecb>.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock
        theCB: BOPDS_CommonBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_SetCommonBlock(self, *args)

    def Shape(self, *args) -> "TopoDS_Shape const":
        r"""
        Selector returns the shape with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        TopoDS_Shape

        """
        return _BOPDS.BOPDS_DS_Shape(self, *args)

    def ShapeInfo(self, *args) -> "BOPDS_ShapeInfo const &":
        r"""
        Selector returns the information about the shape with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        BOPDS_ShapeInfo

        """
        return _BOPDS.BOPDS_DS_ShapeInfo(self, *args)

    def ShapesSD(self, *args) -> "TColStd_DataMapOfIntegerInteger &":
        r"""
        Selector returns the collection same domain shapes.

        Returns
        -------
        TColStd_DataMapOfIntegerInteger

        """
        return _BOPDS.BOPDS_DS_ShapesSD(self, *args)

    def SharedEdges(self, *args) -> "void":
        r"""
        Returns the indices of edges that are shared for the faces with indices thef1, thef2 //! same domain shapes.

        Parameters
        ----------
        theF1: int
        theF2: int
        theLI: TColStd_ListOfInteger
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_SharedEdges(self, *args)

    def SubShapesOnIn(self, *args) -> "void":
        r"""
        Returns information about on/in sub-shapes of the given faces. @param themvonin the indices of on/in vertices from both faces @param themvcommon the indices of common vertices for both faces @param thepbonin all on/in pave blocks from both faces @param thecommonpb the common pave blocks (that are shared by both faces).

        Parameters
        ----------
        theNF1: int
        theNF2: int
        theMVOnIn: TColStd_MapOfInteger
        theMVCommon: TColStd_MapOfInteger
        thePBOnIn: BOPDS_IndexedMapOfPaveBlock
        theCommonPB: BOPDS_MapOfPaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_SubShapesOnIn(self, *args)

    def UpdateCommonBlock(self, *args) -> "void":
        r"""
        Update the common block thecb.

        Parameters
        ----------
        theCB: BOPDS_CommonBlock
        theFuzz: float

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_UpdateCommonBlock(self, *args)

    def UpdateCommonBlockWithSDVertices(self, *args) -> "void":
        r"""
        Update the pave block of the common block for all shapes in data structure.

        Parameters
        ----------
        theCB: BOPDS_CommonBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_UpdateCommonBlockWithSDVertices(self, *args)

    def UpdateFaceInfoIn(self, *args) -> "void":
        r"""
        Update the state in of face with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        None
        Update the state in for all faces in the given map.

        Parameters
        ----------
        theFaces: TColStd_MapOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_UpdateFaceInfoIn(self, *args)

    def UpdateFaceInfoOn(self, *args) -> "void":
        r"""
        Update the state on of face with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        None
        Update the state on for all faces in the given map.

        Parameters
        ----------
        theFaces: TColStd_MapOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_UpdateFaceInfoOn(self, *args)

    def UpdatePaveBlock(self, *args) -> "void":
        r"""
        Update the pave block thepb.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_UpdatePaveBlock(self, *args)

    def UpdatePaveBlockWithSDVertices(self, *args) -> "void":
        r"""
        Update the pave block for all shapes in data structure.

        Parameters
        ----------
        thePB: BOPDS_PaveBlock

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_UpdatePaveBlockWithSDVertices(self, *args)

    def UpdatePaveBlocks(self, *args) -> "void":
        r"""
        Update the pave blocks for the all shapes in data structure.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_UpdatePaveBlocks(self, *args)

    def UpdatePaveBlocksWithSDVertices(self, *args) -> "void":
        r"""
        Update the pave blocks for all shapes in data structure.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_DS_UpdatePaveBlocksWithSDVertices(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_DS

# Register BOPDS_DS in _BOPDS:
_BOPDS.BOPDS_DS_swigregister(BOPDS_DS)

def BOPDS_DS_NbInterfTypes(*args) -> "Standard_Integer":
    r"""
    Returns the number of types of the interferences.

    Returns
    -------
    int

    """
    return _BOPDS.BOPDS_DS_NbInterfTypes(*args)

class BOPDS_FaceInfo(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"""
        Empty contructor.

        Returns
        -------
        None
        Contructor theallocator - the allocator to manage the memory.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_FaceInfo_swiginit(self, _BOPDS.new_BOPDS_FaceInfo(*args))

    def ChangePaveBlocksIn(self, *args) -> "BOPDS_IndexedMapOfPaveBlock &":
        r"""
        Selector/modifier returns the pave blocks of the face that have state in.

        Returns
        -------
        BOPDS_IndexedMapOfPaveBlock

        """
        return _BOPDS.BOPDS_FaceInfo_ChangePaveBlocksIn(self, *args)

    def ChangePaveBlocksOn(self, *args) -> "BOPDS_IndexedMapOfPaveBlock &":
        r"""
        Selector/modifier returns the pave blocks of the face that have state on.

        Returns
        -------
        BOPDS_IndexedMapOfPaveBlock

        """
        return _BOPDS.BOPDS_FaceInfo_ChangePaveBlocksOn(self, *args)

    def ChangePaveBlocksSc(self, *args) -> "BOPDS_IndexedMapOfPaveBlock &":
        r"""
        No available documentation.

        Returns
        -------
        BOPDS_IndexedMapOfPaveBlock

        """
        return _BOPDS.BOPDS_FaceInfo_ChangePaveBlocksSc(self, *args)

    def ChangeVerticesIn(self, *args) -> "TColStd_MapOfInteger &":
        r"""
        Selector/modifier returns the list of indices for vertices of the face that have state in //! on.

        Returns
        -------
        TColStd_MapOfInteger

        """
        return _BOPDS.BOPDS_FaceInfo_ChangeVerticesIn(self, *args)

    def ChangeVerticesOn(self, *args) -> "TColStd_MapOfInteger &":
        r"""
        Selector/modifier returns the list of indices for vertices of the face that have state on //! sections.

        Returns
        -------
        TColStd_MapOfInteger

        """
        return _BOPDS.BOPDS_FaceInfo_ChangeVerticesOn(self, *args)

    def ChangeVerticesSc(self, *args) -> "TColStd_MapOfInteger &":
        r"""
        Selector/modifier returns the list of indices for section vertices of the face //! others.

        Returns
        -------
        TColStd_MapOfInteger

        """
        return _BOPDS.BOPDS_FaceInfo_ChangeVerticesSc(self, *args)

    def Clear(self, *args) -> "void":
        r"""
        Clears the contents.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_FaceInfo_Clear(self, *args)

    def Index(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the index of the face //! in.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_FaceInfo_Index(self, *args)

    def PaveBlocksIn(self, *args) -> "BOPDS_IndexedMapOfPaveBlock const &":
        r"""
        Selector returns the pave blocks of the face that have state in.

        Returns
        -------
        BOPDS_IndexedMapOfPaveBlock

        """
        return _BOPDS.BOPDS_FaceInfo_PaveBlocksIn(self, *args)

    def PaveBlocksOn(self, *args) -> "BOPDS_IndexedMapOfPaveBlock const &":
        r"""
        Selector returns the pave blocks of the face that have state on.

        Returns
        -------
        BOPDS_IndexedMapOfPaveBlock

        """
        return _BOPDS.BOPDS_FaceInfo_PaveBlocksOn(self, *args)

    def PaveBlocksSc(self, *args) -> "BOPDS_IndexedMapOfPaveBlock const &":
        r"""
        Selector returns the pave blocks of the face that are pave blocks of section edges.

        Returns
        -------
        BOPDS_IndexedMapOfPaveBlock

        """
        return _BOPDS.BOPDS_FaceInfo_PaveBlocksSc(self, *args)

    def SetIndex(self, *args) -> "void":
        r"""
        Modifier sets the index of the face <thei>.

        Parameters
        ----------
        theI: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_FaceInfo_SetIndex(self, *args)

    def VerticesIn(self, *args) -> "TColStd_MapOfInteger const &":
        r"""
        Selector returns the list of indices for vertices of the face that have state in.

        Returns
        -------
        TColStd_MapOfInteger

        """
        return _BOPDS.BOPDS_FaceInfo_VerticesIn(self, *args)

    def VerticesOn(self, *args) -> "TColStd_MapOfInteger const &":
        r"""
        Selector returns the list of indices for vertices of the face that have state on.

        Returns
        -------
        TColStd_MapOfInteger

        """
        return _BOPDS.BOPDS_FaceInfo_VerticesOn(self, *args)

    def VerticesSc(self, *args) -> "TColStd_MapOfInteger const &":
        r"""
        Selector returns the list of indices for section vertices of the face.

        Returns
        -------
        TColStd_MapOfInteger

        """
        return _BOPDS.BOPDS_FaceInfo_VerticesSc(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_FaceInfo

# Register BOPDS_FaceInfo in _BOPDS:
_BOPDS.BOPDS_FaceInfo_swigregister(BOPDS_FaceInfo)

class BOPDS_IndexRange(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"""
        Empty contructor.

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_IndexRange_swiginit(self, _BOPDS.new_BOPDS_IndexRange(*args))

    def Contains(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the range contains <theindex>.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_IndexRange_Contains(self, *args)

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

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_IndexRange_Dump(self, *args)

    def First(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the first index of the range.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_IndexRange_First(self, *args)

    def Indices(self, *args) -> "void":
        r"""
        Selector returns the first index of the range <thei1> returns the second index of the range <thei2>.

        Parameters
        ----------

        Returns
        -------
        theI1: int
        theI2: int

        """
        return _BOPDS.BOPDS_IndexRange_Indices(self, *args)

    def Last(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the second index of the range.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_IndexRange_Last(self, *args)

    def SetFirst(self, *args) -> "void":
        r"""
        Modifier sets the first index <thei1> of the range.

        Parameters
        ----------
        theI1: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_IndexRange_SetFirst(self, *args)

    def SetIndices(self, *args) -> "void":
        r"""
        Modifier sets the first index of the range <thei1> sets the second index of the range <thei2>.

        Parameters
        ----------
        theI1: int
        theI2: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_IndexRange_SetIndices(self, *args)

    def SetLast(self, *args) -> "void":
        r"""
        Modifier sets the second index <thei2> of the range.

        Parameters
        ----------
        theI2: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_IndexRange_SetLast(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_IndexRange

# Register BOPDS_IndexRange in _BOPDS:
_BOPDS.BOPDS_IndexRange_swigregister(BOPDS_IndexRange)

class BOPDS_Iterator(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"""
        Empty contructor.

        Returns
        -------
        None
        Contructor theallocator - the allocator to manage the memory.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_Iterator_swiginit(self, _BOPDS.new_BOPDS_Iterator(*args))

    def BlockLength(self, *args) -> "Standard_Integer":
        r"""
        Returns the block length.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_Iterator_BlockLength(self, *args)

    def DS(self, *args) -> "BOPDS_DS const &":
        r"""
        Selector returns the data structure.

        Returns
        -------
        BOPDS_DS

        """
        return _BOPDS.BOPDS_Iterator_DS(self, *args)

    def ExpectedLength(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of intersections founded.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_Iterator_ExpectedLength(self, *args)

    def Initialize(self, *args) -> "void":
        r"""
        Initializes the iterator thetype1 - the first type of shape thetype2 - the second type of shape.

        Parameters
        ----------
        theType1: TopAbs_ShapeEnum
        theType2: TopAbs_ShapeEnum

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Iterator_Initialize(self, *args)

    def IntersectExt(self, *args) -> "void":
        r"""
        Updates the tree of bounding boxes with increased boxes and intersects such elements with the tree.

        Parameters
        ----------
        theIndicies: TColStd_MapOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Iterator_IntersectExt(self, *args)

    def More(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if still there are pairs of intersected shapes.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_Iterator_More(self, *args)

    @staticmethod
    def NbExtInterfs(*args) -> "Standard_Integer":
        r"""
        No available documentation.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_Iterator_NbExtInterfs(*args)

    def Next(self, *args) -> "void":
        r"""
        Moves iterations ahead.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Iterator_Next(self, *args)

    def Prepare(self, *args) -> "void":
        r"""
        Perform the intersection algorithm and prepare the results to be used.

        Parameters
        ----------
        theCtx: IntTools_Context,optional
        	default value is opencascade::handle<IntTools_Context>()
        theCheckOBB: bool,optional
        	default value is Standard_False
        theFuzzyValue: float,optional
        	default value is Precision::Confusion()

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Iterator_Prepare(self, *args)

    def RunParallel(self, *args) -> "Standard_Boolean":
        r"""
        Returns the flag of parallel processing.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_Iterator_RunParallel(self, *args)

    def SetDS(self, *args) -> "void":
        r"""
        Modifier sets the data structure <pds> to process.

        Parameters
        ----------
        pDS: BOPDS_PDS

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Iterator_SetDS(self, *args)

    def SetRunParallel(self, *args) -> "void":
        r"""
        Set the flag of parallel processing if <theflag> is true the parallel processing is switched on if <theflag> is false the parallel processing is switched off.

        Parameters
        ----------
        theFlag: bool

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Iterator_SetRunParallel(self, *args)

    def Value(self, *args) -> "void":
        r"""
        Returns indices (ds) of intersected shapes theindex1 - the index of the first shape theindex2 - the index of the second shape.

        Parameters
        ----------

        Returns
        -------
        theIndex1: int
        theIndex2: int

        """
        return _BOPDS.BOPDS_Iterator_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_Iterator

# Register BOPDS_Iterator in _BOPDS:
_BOPDS.BOPDS_Iterator_swigregister(BOPDS_Iterator)

def BOPDS_Iterator_NbExtInterfs(*args) -> "Standard_Integer":
    r"""
    No available documentation.

    Returns
    -------
    int

    """
    return _BOPDS.BOPDS_Iterator_NbExtInterfs(*args)

class BOPDS_Pair(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"""
        No available documentation.

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        theIndex1: int
        theIndex2: int

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_Pair_swiginit(self, _BOPDS.new_BOPDS_Pair(*args))

    def HashCode(self, *args) -> "Standard_Integer":
        r"""
        Computes a hash code for this pair, in the range [1, theupperbound] @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
        ----------
        theUpperBound: int

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_Pair_HashCode(self, *args)

    def __hash__(self) -> "Standard_Integer":
        return _BOPDS.BOPDS_Pair___hash__(self)

    def Indices(self, *args) -> "void":
        r"""
        Gets the indices.

        Parameters
        ----------

        Returns
        -------
        theIndex1: int
        theIndex2: int

        """
        return _BOPDS.BOPDS_Pair_Indices(self, *args)

    def IsEqual(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the pair is equal to <the theother>.

        Parameters
        ----------
        theOther: BOPDS_Pair

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_Pair_IsEqual(self, *args)

    def SetIndices(self, *args) -> "void":
        r"""
        Sets the indices.

        Parameters
        ----------
        theIndex1: int
        theIndex2: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Pair_SetIndices(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_Pair

# Register BOPDS_Pair in _BOPDS:
_BOPDS.BOPDS_Pair_swigregister(BOPDS_Pair)

class BOPDS_PairMapHasher(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"""
        Computes a hash code for the given pair, in the range [1, theupperbound] @param thepair the pair 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
        ----------
        thePair: BOPDS_Pair
        theUpperBound: int

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_PairMapHasher_HashCode(*args)

    @staticmethod
    def IsEqual(*args) -> "Standard_Boolean":
        r"""
        No available documentation.

        Parameters
        ----------
        thePair1: BOPDS_Pair
        thePair2: BOPDS_Pair

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_PairMapHasher_IsEqual(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _BOPDS.BOPDS_PairMapHasher_swiginit(self, _BOPDS.new_BOPDS_PairMapHasher())
    __swig_destroy__ = _BOPDS.delete_BOPDS_PairMapHasher

# Register BOPDS_PairMapHasher in _BOPDS:
_BOPDS.BOPDS_PairMapHasher_swigregister(BOPDS_PairMapHasher)

def BOPDS_PairMapHasher_HashCode(*args) -> "Standard_Integer":
    r"""
    Computes a hash code for the given pair, in the range [1, theupperbound] @param thepair the pair 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
    ----------
    thePair: BOPDS_Pair
    theUpperBound: int

    Returns
    -------
    int

    """
    return _BOPDS.BOPDS_PairMapHasher_HashCode(*args)

def BOPDS_PairMapHasher_IsEqual(*args) -> "Standard_Boolean":
    r"""
    No available documentation.

    Parameters
    ----------
    thePair1: BOPDS_Pair
    thePair2: BOPDS_Pair

    Returns
    -------
    bool

    """
    return _BOPDS.BOPDS_PairMapHasher_IsEqual(*args)

class BOPDS_Pave(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"""
        Empty contructor.

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_Pave_swiginit(self, _BOPDS.new_BOPDS_Pave(*args))

    def Contents(self, *args) -> "void":
        r"""
        Selector returns the index of vertex <theindex> returns the parameter of vertex <theparameter>.

        Parameters
        ----------

        Returns
        -------
        theIndex: int
        theParameter: float

        """
        return _BOPDS.BOPDS_Pave_Contents(self, *args)

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

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Pave_Dump(self, *args)

    def Index(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the index of vertex.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_Pave_Index(self, *args)

    def IsEqual(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if thr parameter od this is equal to the parameter of <theother>.

        Parameters
        ----------
        theOther: BOPDS_Pave

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_Pave_IsEqual(self, *args)

    def IsLess(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if thr parameter od this is less than the parameter of <theother>.

        Parameters
        ----------
        theOther: BOPDS_Pave

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_Pave_IsLess(self, *args)

    def Parameter(self, *args) -> "Standard_Real":
        r"""
        Selector returns the parameter of vertex.

        Returns
        -------
        float

        """
        return _BOPDS.BOPDS_Pave_Parameter(self, *args)

    def SetIndex(self, *args) -> "void":
        r"""
        Modifier sets the index of vertex <theindex>.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Pave_SetIndex(self, *args)

    def SetParameter(self, *args) -> "void":
        r"""
        Modifier sets the parameter of vertex <theparameter>.

        Parameters
        ----------
        theParameter: float

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Pave_SetParameter(self, *args)

    def __eq_wrapper__(self, other: "BOPDS_Pave") -> "bool":
        return _BOPDS.BOPDS_Pave___eq_wrapper__(self, other)

    def __eq__(self, right):
        try:
            return self.__eq_wrapper__(right)
        except:
            return False


    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_Pave

# Register BOPDS_Pave in _BOPDS:
_BOPDS.BOPDS_Pave_swigregister(BOPDS_Pave)

class BOPDS_PaveBlock(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"""
        Empty contructor.

        Returns
        -------
        None
        Contructor <theallocator> - the allocator to manage the memory.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_PaveBlock_swiginit(self, _BOPDS.new_BOPDS_PaveBlock(*args))

    def AppendExtPave(self, *args) -> "void":
        r"""
        Modifier appends extra paves <thepave>.

        Parameters
        ----------
        thePave: BOPDS_Pave

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_AppendExtPave(self, *args)

    def AppendExtPave1(self, *args) -> "void":
        r"""
        Modifier appends extra pave <thepave>.

        Parameters
        ----------
        thePave: BOPDS_Pave

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_AppendExtPave1(self, *args)

    def ChangeExtPaves(self, *args) -> "BOPDS_ListOfPave &":
        r"""
        Selector / modifier returns the extra paves.

        Returns
        -------
        BOPDS_ListOfPave

        """
        return _BOPDS.BOPDS_PaveBlock_ChangeExtPaves(self, *args)

    def ContainsParameter(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the extra paves contain the pave with given value of the parameter <theprm> <thetol> - the value of the tolerance to compare <theind> - index of the found pave.

        Parameters
        ----------
        thePrm: float
        theTol: float

        Returns
        -------
        theInd: int

        """
        return _BOPDS.BOPDS_PaveBlock_ContainsParameter(self, *args)

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

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_Dump(self, *args)

    def Edge(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the index of edge of pave block.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_PaveBlock_Edge(self, *args)

    def ExtPaves(self, *args) -> "BOPDS_ListOfPave const &":
        r"""
        Selector returns the extra paves.

        Returns
        -------
        BOPDS_ListOfPave

        """
        return _BOPDS.BOPDS_PaveBlock_ExtPaves(self, *args)

    def HasEdge(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the pave block has edge.

        Returns
        -------
        bool
        Query returns true if the pave block has edge returns the index of edge <theedge>.

        Parameters
        ----------

        Returns
        -------
        theEdge: int

        """
        return _BOPDS.BOPDS_PaveBlock_HasEdge(self, *args)

    def HasSameBounds(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the pave block has pave indices that equal to the pave indices of the pave block <theother>.

        Parameters
        ----------
        theOther: BOPDS_PaveBlock

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_PaveBlock_HasSameBounds(self, *args)

    def HasShrunkData(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the pave block contains the shrunk data.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_PaveBlock_HasShrunkData(self, *args)

    def Indices(self, *args) -> "void":
        r"""
        Selector returns the pave indices <theindex1,theindex2> of the pave block.

        Parameters
        ----------

        Returns
        -------
        theIndex1: int
        theIndex2: int

        """
        return _BOPDS.BOPDS_PaveBlock_Indices(self, *args)

    def IsSplitEdge(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the edge is equal to the original edge of the pave block.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_PaveBlock_IsSplitEdge(self, *args)

    def IsSplittable(self, *args) -> "Standard_Boolean":
        r"""
        Query returns false if the pave block has a too short shrunk range and cannot be split, otherwise returns true.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_PaveBlock_IsSplittable(self, *args)

    def IsToUpdate(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the pave block contains extra paves.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_PaveBlock_IsToUpdate(self, *args)

    def OriginalEdge(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the index of original edge of pave block.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_PaveBlock_OriginalEdge(self, *args)

    def Pave1(self, *args) -> "BOPDS_Pave const &":
        r"""
        Selector returns the first pave.

        Returns
        -------
        BOPDS_Pave

        """
        return _BOPDS.BOPDS_PaveBlock_Pave1(self, *args)

    def Pave2(self, *args) -> "BOPDS_Pave const &":
        r"""
        Selector returns the second pave.

        Returns
        -------
        BOPDS_Pave

        """
        return _BOPDS.BOPDS_PaveBlock_Pave2(self, *args)

    def Range(self, *args) -> "void":
        r"""
        Selector returns the parametric range <thet1,thet2> of the pave block.

        Parameters
        ----------

        Returns
        -------
        theT1: float
        theT2: float

        """
        return _BOPDS.BOPDS_PaveBlock_Range(self, *args)

    def RemoveExtPave(self, *args) -> "void":
        r"""
        Modifier removes a pave with the given vertex number from extra paves.

        Parameters
        ----------
        theVertNum: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_RemoveExtPave(self, *args)

    def SetEdge(self, *args) -> "void":
        r"""
        Modifier sets the index of edge of pave block <theedge>.

        Parameters
        ----------
        theEdge: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_SetEdge(self, *args)

    def SetOriginalEdge(self, *args) -> "void":
        r"""
        Modifier sets the index of original edge of the pave block <theedge>.

        Parameters
        ----------
        theEdge: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_SetOriginalEdge(self, *args)

    def SetPave1(self, *args) -> "void":
        r"""
        Modifier sets the first pave <thepave>.

        Parameters
        ----------
        thePave: BOPDS_Pave

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_SetPave1(self, *args)

    def SetPave2(self, *args) -> "void":
        r"""
        Modifier sets the second pave <thepave>.

        Parameters
        ----------
        thePave: BOPDS_Pave

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_SetPave2(self, *args)

    def SetShrunkData(self, *args) -> "void":
        r"""
        Modifier sets the shrunk data for the pave block <thets1>, <thets2> - shrunk range <thebox> - the bounding box <theissplittable> - defines whether the edge can be split.

        Parameters
        ----------
        theTS1: float
        theTS2: float
        theBox: Bnd_Box
        theIsSplittable: bool

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_SetShrunkData(self, *args)

    def ShrunkData(self, *args) -> "void":
        r"""
        Selector returns the shrunk data for the pave block <thets1>, <thets2> - shrunk range <thebox> - the bounding box <theissplittable> - defines whether the edge can be split.

        Parameters
        ----------
        theBox: Bnd_Box

        Returns
        -------
        theTS1: float
        theTS2: float
        theIsSplittable: bool

        """
        return _BOPDS.BOPDS_PaveBlock_ShrunkData(self, *args)

    def Update(self, *args) -> "void":
        r"""
        Modifier updates the pave block. the extra paves are used to create new pave blocks <thelpb>. <theflag> - if true, the first pave and the second pave are used to produce new pave blocks.

        Parameters
        ----------
        theLPB: BOPDS_ListOfPaveBlock
        theFlag: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_PaveBlock_Update(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_PaveBlock

# Register BOPDS_PaveBlock in _BOPDS:
_BOPDS.BOPDS_PaveBlock_swigregister(BOPDS_PaveBlock)

class BOPDS_PaveMapHasher(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"""
        Computes a hash code for the given pave, in the range [1, theupperbound] @param thepave the pave 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
        ----------
        thePave: BOPDS_Pave
        theUpperBound: int

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_PaveMapHasher_HashCode(*args)

    @staticmethod
    def IsEqual(*args) -> "Standard_Boolean":
        r"""
        No available documentation.

        Parameters
        ----------
        aPave1: BOPDS_Pave
        aPave2: BOPDS_Pave

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_PaveMapHasher_IsEqual(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _BOPDS.BOPDS_PaveMapHasher_swiginit(self, _BOPDS.new_BOPDS_PaveMapHasher())
    __swig_destroy__ = _BOPDS.delete_BOPDS_PaveMapHasher

# Register BOPDS_PaveMapHasher in _BOPDS:
_BOPDS.BOPDS_PaveMapHasher_swigregister(BOPDS_PaveMapHasher)

def BOPDS_PaveMapHasher_HashCode(*args) -> "Standard_Integer":
    r"""
    Computes a hash code for the given pave, in the range [1, theupperbound] @param thepave the pave 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
    ----------
    thePave: BOPDS_Pave
    theUpperBound: int

    Returns
    -------
    int

    """
    return _BOPDS.BOPDS_PaveMapHasher_HashCode(*args)

def BOPDS_PaveMapHasher_IsEqual(*args) -> "Standard_Boolean":
    r"""
    No available documentation.

    Parameters
    ----------
    aPave1: BOPDS_Pave
    aPave2: BOPDS_Pave

    Returns
    -------
    bool

    """
    return _BOPDS.BOPDS_PaveMapHasher_IsEqual(*args)

class BOPDS_Point(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"""
        Empty contructor.

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_Point_swiginit(self, _BOPDS.new_BOPDS_Point(*args))

    def Index(self, *args) -> "Standard_Integer":
        r"""
        Selector returns index of the vertex.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_Point_Index(self, *args)

    def Pnt(self, *args) -> "gp_Pnt const":
        r"""
        Selector returns 3d point.

        Returns
        -------
        gp_Pnt

        """
        return _BOPDS.BOPDS_Point_Pnt(self, *args)

    def Pnt2D1(self, *args) -> "gp_Pnt2d const":
        r"""
        Selector returns 2d point on the first face <thepnt>.

        Returns
        -------
        gp_Pnt2d

        """
        return _BOPDS.BOPDS_Point_Pnt2D1(self, *args)

    def Pnt2D2(self, *args) -> "gp_Pnt2d const":
        r"""
        Selector returns 2d point on the second face <thepnt>.

        Returns
        -------
        gp_Pnt2d

        """
        return _BOPDS.BOPDS_Point_Pnt2D2(self, *args)

    def SetIndex(self, *args) -> "void":
        r"""
        Modifier sets the index of the vertex <theindex>.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Point_SetIndex(self, *args)

    def SetPnt(self, *args) -> "void":
        r"""
        Modifier sets 3d point <thepnt>.

        Parameters
        ----------
        thePnt: gp_Pnt

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Point_SetPnt(self, *args)

    def SetPnt2D1(self, *args) -> "void":
        r"""
        Modifier sets 2d point on the first face <thepnt>.

        Parameters
        ----------
        thePnt: gp_Pnt2d

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Point_SetPnt2D1(self, *args)

    def SetPnt2D2(self, *args) -> "void":
        r"""
        Modifier sets 2d point on the second face <thepnt>.

        Parameters
        ----------
        thePnt: gp_Pnt2d

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_Point_SetPnt2D2(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_Point

# Register BOPDS_Point in _BOPDS:
_BOPDS.BOPDS_Point_swigregister(BOPDS_Point)

class BOPDS_ShapeInfo(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"""
        Empty contructor.

        Returns
        -------
        None
        Contructor theallocator - the allocator to manage the memory.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_ShapeInfo_swiginit(self, _BOPDS.new_BOPDS_ShapeInfo(*args))

    def Box(self, *args) -> "Bnd_Box const &":
        r"""
        Selector returns the boundung box of the shape.

        Returns
        -------
        Bnd_Box

        """
        return _BOPDS.BOPDS_ShapeInfo_Box(self, *args)

    def ChangeBox(self, *args) -> "Bnd_Box &":
        r"""
        Selector/modifier returns the boundung box of the shape.

        Returns
        -------
        Bnd_Box

        """
        return _BOPDS.BOPDS_ShapeInfo_ChangeBox(self, *args)

    def ChangeSubShapes(self, *args) -> "TColStd_ListOfInteger &":
        r"""
        Selector/ modifier returns the list of indices of sub-shapes.

        Returns
        -------
        TColStd_ListOfInteger

        """
        return _BOPDS.BOPDS_ShapeInfo_ChangeSubShapes(self, *args)

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

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_ShapeInfo_Dump(self, *args)

    def Flag(self, *args) -> "Standard_Integer":
        r"""
        Returns the flag.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_ShapeInfo_Flag(self, *args)

    def HasBRep(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the shape has boundary representation.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_ShapeInfo_HasBRep(self, *args)

    def HasFlag(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if there is flag.

        Returns
        -------
        bool
        Query returns true if there is flag. returns the the flag theflag.

        Parameters
        ----------

        Returns
        -------
        theFlag: int

        """
        return _BOPDS.BOPDS_ShapeInfo_HasFlag(self, *args)

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

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_ShapeInfo_HasReference(self, *args)

    def HasSubShape(self, *args) -> "Standard_Boolean":
        r"""
        Query returns true if the shape has sub-shape with index thei.

        Parameters
        ----------
        theI: int

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_ShapeInfo_HasSubShape(self, *args)

    def IsInterfering(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the shape can be participant of an interference //! flag.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_ShapeInfo_IsInterfering(self, *args)

    def Reference(self, *args) -> "Standard_Integer":
        r"""
        Selector returns the index of a reference information.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_ShapeInfo_Reference(self, *args)

    def SetBox(self, *args) -> "void":
        r"""
        Modifier sets the boundung box of the shape thebox.

        Parameters
        ----------
        theBox: Bnd_Box

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_ShapeInfo_SetBox(self, *args)

    def SetFlag(self, *args) -> "void":
        r"""
        Modifier sets the flag.

        Parameters
        ----------
        theI: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_ShapeInfo_SetFlag(self, *args)

    def SetReference(self, *args) -> "void":
        r"""
        Modifier sets the index of a reference information.

        Parameters
        ----------
        theI: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_ShapeInfo_SetReference(self, *args)

    def SetShape(self, *args) -> "void":
        r"""
        Modifier sets the shape <thes>.

        Parameters
        ----------
        theS: TopoDS_Shape

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_ShapeInfo_SetShape(self, *args)

    def SetShapeType(self, *args) -> "void":
        r"""
        Modifier sets the type of shape thetype.

        Parameters
        ----------
        theType: TopAbs_ShapeEnum

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_ShapeInfo_SetShapeType(self, *args)

    def Shape(self, *args) -> "TopoDS_Shape const":
        r"""
        Selector returns the shape.

        Returns
        -------
        TopoDS_Shape

        """
        return _BOPDS.BOPDS_ShapeInfo_Shape(self, *args)

    def ShapeType(self, *args) -> "TopAbs_ShapeEnum":
        r"""
        Selector returns the type of shape.

        Returns
        -------
        TopAbs_ShapeEnum

        """
        return _BOPDS.BOPDS_ShapeInfo_ShapeType(self, *args)

    def SubShapes(self, *args) -> "TColStd_ListOfInteger const &":
        r"""
        Selector returns the list of indices of sub-shapes.

        Returns
        -------
        TColStd_ListOfInteger

        """
        return _BOPDS.BOPDS_ShapeInfo_SubShapes(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_ShapeInfo

# Register BOPDS_ShapeInfo in _BOPDS:
_BOPDS.BOPDS_ShapeInfo_swigregister(BOPDS_ShapeInfo)

class BOPDS_SubIterator(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"""
        Empty constructor.

        Returns
        -------
        None
        Constructor theallocator - the allocator to manage the memory.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_SubIterator_swiginit(self, _BOPDS.new_BOPDS_SubIterator(*args))

    def DS(self, *args) -> "BOPDS_DS const &":
        r"""
        Returns the data structure.

        Returns
        -------
        BOPDS_DS

        """
        return _BOPDS.BOPDS_SubIterator_DS(self, *args)

    def ExpectedLength(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of interfering pairs.

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_SubIterator_ExpectedLength(self, *args)

    def Initialize(self, *args) -> "void":
        r"""
        Initializes the iterator.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_SubIterator_Initialize(self, *args)

    def More(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if there are more pairs of intersected shapes.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_SubIterator_More(self, *args)

    def Next(self, *args) -> "void":
        r"""
        Moves iterations ahead.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_SubIterator_Next(self, *args)

    def Prepare(self, *args) -> "void":
        r"""
        Perform the intersection algorithm and prepare the results to be used.

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_SubIterator_Prepare(self, *args)

    def SetDS(self, *args) -> "void":
        r"""
        Sets the data structure <pds> to process. it is used to access the shapes and their bounding boxes.

        Parameters
        ----------
        pDS: BOPDS_PDS

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_SubIterator_SetDS(self, *args)

    def SetSubSet1(self, *args) -> "void":
        r"""
        Sets the first set of indices <theli> to process.

        Parameters
        ----------
        theLI: TColStd_ListOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_SubIterator_SetSubSet1(self, *args)

    def SetSubSet2(self, *args) -> "void":
        r"""
        Sets the second set of indices <theli> to process.

        Parameters
        ----------
        theLI: TColStd_ListOfInteger

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_SubIterator_SetSubSet2(self, *args)

    def SubSet1(self, *args) -> "TColStd_ListOfInteger const &":
        r"""
        Returns the first set of indices to process.

        Returns
        -------
        TColStd_ListOfInteger

        """
        return _BOPDS.BOPDS_SubIterator_SubSet1(self, *args)

    def SubSet2(self, *args) -> "TColStd_ListOfInteger const &":
        r"""
        Returns the second set of indices to process.

        Returns
        -------
        TColStd_ListOfInteger

        """
        return _BOPDS.BOPDS_SubIterator_SubSet2(self, *args)

    def Value(self, *args) -> "void":
        r"""
        Returns indices (ds) of intersected shapes theindex1 - the index of the first shape theindex2 - the index of the second shape.

        Parameters
        ----------

        Returns
        -------
        theIndex1: int
        theIndex2: int

        """
        return _BOPDS.BOPDS_SubIterator_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_SubIterator

# Register BOPDS_SubIterator in _BOPDS:
_BOPDS.BOPDS_SubIterator_swigregister(BOPDS_SubIterator)

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

    @staticmethod
    def HasBRep(*args) -> "Standard_Boolean":
        r"""
        Returns true if the type <thet> correspond to a shape having boundary representation.

        Parameters
        ----------
        theT: TopAbs_ShapeEnum

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_Tools_HasBRep(*args)

    @staticmethod
    def IsInterfering(*args) -> "Standard_Boolean":
        r"""
        Returns true if the type <thet> can be participant of an interference.

        Parameters
        ----------
        theT: TopAbs_ShapeEnum

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_Tools_IsInterfering(*args)

    @staticmethod
    def TypeToInteger(*args) -> "Standard_Integer":
        r"""
        Converts the conmbination of two types of shape <thet1>,<thet2> to the one integer value, that is returned.

        Parameters
        ----------
        theT1: TopAbs_ShapeEnum
        theT2: TopAbs_ShapeEnum

        Returns
        -------
        int
        Converts the type of shape <thet>, to integer value, that is returned.

        Parameters
        ----------
        theT: TopAbs_ShapeEnum

        Returns
        -------
        int

        """
        return _BOPDS.BOPDS_Tools_TypeToInteger(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _BOPDS.BOPDS_Tools_swiginit(self, _BOPDS.new_BOPDS_Tools())
    __swig_destroy__ = _BOPDS.delete_BOPDS_Tools

# Register BOPDS_Tools in _BOPDS:
_BOPDS.BOPDS_Tools_swigregister(BOPDS_Tools)

def BOPDS_Tools_HasBRep(*args) -> "Standard_Boolean":
    r"""
    Returns true if the type <thet> correspond to a shape having boundary representation.

    Parameters
    ----------
    theT: TopAbs_ShapeEnum

    Returns
    -------
    bool

    """
    return _BOPDS.BOPDS_Tools_HasBRep(*args)

def BOPDS_Tools_IsInterfering(*args) -> "Standard_Boolean":
    r"""
    Returns true if the type <thet> can be participant of an interference.

    Parameters
    ----------
    theT: TopAbs_ShapeEnum

    Returns
    -------
    bool

    """
    return _BOPDS.BOPDS_Tools_IsInterfering(*args)

def BOPDS_Tools_TypeToInteger(*args) -> "Standard_Integer":
    r"""
    Converts the conmbination of two types of shape <thet1>,<thet2> to the one integer value, that is returned.

    Parameters
    ----------
    theT1: TopAbs_ShapeEnum
    theT2: TopAbs_ShapeEnum

    Returns
    -------
    int
    Converts the type of shape <thet>, to integer value, that is returned.

    Parameters
    ----------
    theT: TopAbs_ShapeEnum

    Returns
    -------
    int

    """
    return _BOPDS.BOPDS_Tools_TypeToInteger(*args)

class BOPDS_InterfEE(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param theallocator * allocator to manage the memory */.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfEE_swiginit(self, _BOPDS.new_BOPDS_InterfEE(*args))

    def CommonPart(self, *args) -> "IntTools_CommonPrt const &":
        r"""
        /** * selector * returns the info of common part * returns * common part */.

        Returns
        -------
        IntTools_CommonPrt

        """
        return _BOPDS.BOPDS_InterfEE_CommonPart(self, *args)

    def SetCommonPart(self, *args) -> "void":
        r"""
        /** * modifier * sets the info of common part * @param thecp * common part */.

        Parameters
        ----------
        theCP: IntTools_CommonPrt

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_InterfEE_SetCommonPart(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfEE

# Register BOPDS_InterfEE in _BOPDS:
_BOPDS.BOPDS_InterfEE_swigregister(BOPDS_InterfEE)

class BOPDS_InterfEF(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param theallocator * allocator to manage the memory */.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfEF_swiginit(self, _BOPDS.new_BOPDS_InterfEF(*args))

    def CommonPart(self, *args) -> "IntTools_CommonPrt const &":
        r"""
        /** * selector * returns the info of common part * returns * common part */.

        Returns
        -------
        IntTools_CommonPrt

        """
        return _BOPDS.BOPDS_InterfEF_CommonPart(self, *args)

    def SetCommonPart(self, *args) -> "void":
        r"""
        /** * modifier * sets the info of common part * @param thecp * common part */.

        Parameters
        ----------
        theCP: IntTools_CommonPrt

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_InterfEF_SetCommonPart(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfEF

# Register BOPDS_InterfEF in _BOPDS:
_BOPDS.BOPDS_InterfEF_swigregister(BOPDS_InterfEF)

class BOPDS_InterfEZ(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param theallocator * allocator to manage the memory */.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfEZ_swiginit(self, _BOPDS.new_BOPDS_InterfEZ(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfEZ

# Register BOPDS_InterfEZ in _BOPDS:
_BOPDS.BOPDS_InterfEZ_swigregister(BOPDS_InterfEZ)

class BOPDS_InterfFF(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"""
        /** * constructor */.

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfFF_swiginit(self, _BOPDS.new_BOPDS_InterfFF(*args))

    def ChangeCurves(self, *args) -> "BOPDS_VectorOfCurve &":
        r"""
        /** * selector/modifier * returns the intersection curves * returns * intersection curves */.

        Returns
        -------
        BOPDS_VectorOfCurve

        """
        return _BOPDS.BOPDS_InterfFF_ChangeCurves(self, *args)

    def ChangePoints(self, *args) -> "BOPDS_VectorOfPoint &":
        r"""
        /** * selector/modifier * returns the intersection points * returns * intersection points */.

        Returns
        -------
        BOPDS_VectorOfPoint

        """
        return _BOPDS.BOPDS_InterfFF_ChangePoints(self, *args)

    def Curves(self, *args) -> "BOPDS_VectorOfCurve const &":
        r"""
        /** * selector * returns the intersection curves * returns * intersection curves */.

        Returns
        -------
        BOPDS_VectorOfCurve

        """
        return _BOPDS.BOPDS_InterfFF_Curves(self, *args)

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

        Parameters
        ----------
        theNbCurves: int
        theNbPoints: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_InterfFF_Init(self, *args)

    def Points(self, *args) -> "BOPDS_VectorOfPoint const &":
        r"""
        /** * selector * returns the intersection points * returns * intersection points */.

        Returns
        -------
        BOPDS_VectorOfPoint

        """
        return _BOPDS.BOPDS_InterfFF_Points(self, *args)

    def SetTangentFaces(self, *args) -> "void":
        r"""
        /** * modifier * sets the flag of whether the faces are tangent * @param theflag * the flag */.

        Parameters
        ----------
        theFlag: bool

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_InterfFF_SetTangentFaces(self, *args)

    def TangentFaces(self, *args) -> "Standard_Boolean":
        r"""
        /** * selector * returns the flag whether the faces are tangent * returns * the flag */.

        Returns
        -------
        bool

        """
        return _BOPDS.BOPDS_InterfFF_TangentFaces(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfFF

# Register BOPDS_InterfFF in _BOPDS:
_BOPDS.BOPDS_InterfFF_swigregister(BOPDS_InterfFF)

class BOPDS_InterfFZ(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param theallocator * allocator to manage the memory */.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfFZ_swiginit(self, _BOPDS.new_BOPDS_InterfFZ(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfFZ

# Register BOPDS_InterfFZ in _BOPDS:
_BOPDS.BOPDS_InterfFZ_swigregister(BOPDS_InterfFZ)

class BOPDS_InterfVE(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param theallocator * allocator to manage the memory */.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfVE_swiginit(self, _BOPDS.new_BOPDS_InterfVE(*args))

    def Parameter(self, *args) -> "Standard_Real":
        r"""
        /** * selector * returrns the value of parameter * of the point of the vertex * on the curve of the edge * returns * value of parameter */.

        Returns
        -------
        float

        """
        return _BOPDS.BOPDS_InterfVE_Parameter(self, *args)

    def SetParameter(self, *args) -> "void":
        r"""
        /** * modifier * sets the value of parameter * of the point of the vertex * on the curve of the edge * @param thet * value of parameter */.

        Parameters
        ----------
        theT: float

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_InterfVE_SetParameter(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfVE

# Register BOPDS_InterfVE in _BOPDS:
_BOPDS.BOPDS_InterfVE_swigregister(BOPDS_InterfVE)

class BOPDS_InterfVF(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param theallocator * allocator to manage the memory */.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfVF_swiginit(self, _BOPDS.new_BOPDS_InterfVF(*args))

    def SetUV(self, *args) -> "void":
        r"""
        /** * modifier * sets the value of parameters * of the point of the vertex * on the surface of of the face * @param theu * value of u parameter * @param thev * value of u parameter */.

        Parameters
        ----------
        theU: float
        theV: float

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_InterfVF_SetUV(self, *args)

    def UV(self, *args) -> "void":
        r"""
        /** * selector * returns the value of parameters * of the point of the vertex * on the surface of of the face * @param theu * value of u parameter * @param thev * value of u parameter */.

        Parameters
        ----------

        Returns
        -------
        theU: float
        theV: float

        """
        return _BOPDS.BOPDS_InterfVF_UV(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfVF

# Register BOPDS_InterfVF in _BOPDS:
_BOPDS.BOPDS_InterfVF_swigregister(BOPDS_InterfVF)

class BOPDS_InterfVV(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param theallocator * allocator to manage the memory */.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfVV_swiginit(self, _BOPDS.new_BOPDS_InterfVV(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfVV

# Register BOPDS_InterfVV in _BOPDS:
_BOPDS.BOPDS_InterfVV_swigregister(BOPDS_InterfVV)

class BOPDS_InterfVZ(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param theallocator * allocator to manage the memory */.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfVZ_swiginit(self, _BOPDS.new_BOPDS_InterfVZ(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfVZ

# Register BOPDS_InterfVZ in _BOPDS:
_BOPDS.BOPDS_InterfVZ_swigregister(BOPDS_InterfVZ)

class BOPDS_InterfZZ(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"""
        /** * constructor */.

        Returns
        -------
        None
        /** * constructor * @param theallocator * allocator to manage the memory */.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_InterfZZ_swiginit(self, _BOPDS.new_BOPDS_InterfZZ(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_InterfZZ

# Register BOPDS_InterfZZ in _BOPDS:
_BOPDS.BOPDS_InterfZZ_swigregister(BOPDS_InterfZZ)

class BOPDS_IteratorSI(BOPDS_Iterator):
    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"""
        Empty contructor.

        Returns
        -------
        None
        Contructor theallocator - the allocator to manage the memory.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _BOPDS.BOPDS_IteratorSI_swiginit(self, _BOPDS.new_BOPDS_IteratorSI(*args))

    def UpdateByLevelOfCheck(self, *args) -> "void":
        r"""
        Updates the lists of possible intersections according to the value of <thelevel>. it defines which interferferences will be checked: 0 - only v/v; 1 - v/v and v/e; 2 - v/v, v/e and e/e; 3 - v/v, v/e, e/e and v/f; 4 - v/v, v/e, e/e, v/f and e/f; other - all interferences.

        Parameters
        ----------
        theLevel: int

        Returns
        -------
        None

        """
        return _BOPDS.BOPDS_IteratorSI_UpdateByLevelOfCheck(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BOPDS.delete_BOPDS_IteratorSI

# Register BOPDS_IteratorSI in _BOPDS:
_BOPDS.BOPDS_IteratorSI_swigregister(BOPDS_IteratorSI)


@classnotwrapped
class BOPDS_Interf:
	pass






