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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _TColStd:
_TColStd.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 _TColStd.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.TCollection

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




def Handle_TColStd_HPackedMapOfInteger_Create() -> "opencascade::handle< TColStd_HPackedMapOfInteger >":
    return _TColStd.Handle_TColStd_HPackedMapOfInteger_Create()

def Handle_TColStd_HPackedMapOfInteger_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HPackedMapOfInteger >":
    return _TColStd.Handle_TColStd_HPackedMapOfInteger_DownCast(t)

def Handle_TColStd_HPackedMapOfInteger_IsNull(t: "opencascade::handle< TColStd_HPackedMapOfInteger > const &") -> "bool":
    return _TColStd.Handle_TColStd_HPackedMapOfInteger_IsNull(t)

def Handle_TColStd_HArray1OfExtendedString_Create() -> "opencascade::handle< TColStd_HArray1OfExtendedString >":
    return _TColStd.Handle_TColStd_HArray1OfExtendedString_Create()

def Handle_TColStd_HArray1OfExtendedString_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray1OfExtendedString >":
    return _TColStd.Handle_TColStd_HArray1OfExtendedString_DownCast(t)

def Handle_TColStd_HArray1OfExtendedString_IsNull(t: "opencascade::handle< TColStd_HArray1OfExtendedString > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray1OfExtendedString_IsNull(t)

def Handle_TColStd_HArray1OfCharacter_Create() -> "opencascade::handle< TColStd_HArray1OfCharacter >":
    return _TColStd.Handle_TColStd_HArray1OfCharacter_Create()

def Handle_TColStd_HArray1OfCharacter_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray1OfCharacter >":
    return _TColStd.Handle_TColStd_HArray1OfCharacter_DownCast(t)

def Handle_TColStd_HArray1OfCharacter_IsNull(t: "opencascade::handle< TColStd_HArray1OfCharacter > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray1OfCharacter_IsNull(t)

def Handle_TColStd_HArray1OfBoolean_Create() -> "opencascade::handle< TColStd_HArray1OfBoolean >":
    return _TColStd.Handle_TColStd_HArray1OfBoolean_Create()

def Handle_TColStd_HArray1OfBoolean_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray1OfBoolean >":
    return _TColStd.Handle_TColStd_HArray1OfBoolean_DownCast(t)

def Handle_TColStd_HArray1OfBoolean_IsNull(t: "opencascade::handle< TColStd_HArray1OfBoolean > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray1OfBoolean_IsNull(t)

def Handle_TColStd_HArray1OfAsciiString_Create() -> "opencascade::handle< TColStd_HArray1OfAsciiString >":
    return _TColStd.Handle_TColStd_HArray1OfAsciiString_Create()

def Handle_TColStd_HArray1OfAsciiString_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray1OfAsciiString >":
    return _TColStd.Handle_TColStd_HArray1OfAsciiString_DownCast(t)

def Handle_TColStd_HArray1OfAsciiString_IsNull(t: "opencascade::handle< TColStd_HArray1OfAsciiString > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray1OfAsciiString_IsNull(t)

def Handle_TColStd_HArray1OfReal_Create() -> "opencascade::handle< TColStd_HArray1OfReal >":
    return _TColStd.Handle_TColStd_HArray1OfReal_Create()

def Handle_TColStd_HArray1OfReal_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray1OfReal >":
    return _TColStd.Handle_TColStd_HArray1OfReal_DownCast(t)

def Handle_TColStd_HArray1OfReal_IsNull(t: "opencascade::handle< TColStd_HArray1OfReal > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray1OfReal_IsNull(t)

def Handle_TColStd_HArray1OfInteger_Create() -> "opencascade::handle< TColStd_HArray1OfInteger >":
    return _TColStd.Handle_TColStd_HArray1OfInteger_Create()

def Handle_TColStd_HArray1OfInteger_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray1OfInteger >":
    return _TColStd.Handle_TColStd_HArray1OfInteger_DownCast(t)

def Handle_TColStd_HArray1OfInteger_IsNull(t: "opencascade::handle< TColStd_HArray1OfInteger > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray1OfInteger_IsNull(t)

def Handle_TColStd_HArray1OfListOfInteger_Create() -> "opencascade::handle< TColStd_HArray1OfListOfInteger >":
    return _TColStd.Handle_TColStd_HArray1OfListOfInteger_Create()

def Handle_TColStd_HArray1OfListOfInteger_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray1OfListOfInteger >":
    return _TColStd.Handle_TColStd_HArray1OfListOfInteger_DownCast(t)

def Handle_TColStd_HArray1OfListOfInteger_IsNull(t: "opencascade::handle< TColStd_HArray1OfListOfInteger > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray1OfListOfInteger_IsNull(t)

def Handle_TColStd_HArray1OfTransient_Create() -> "opencascade::handle< TColStd_HArray1OfTransient >":
    return _TColStd.Handle_TColStd_HArray1OfTransient_Create()

def Handle_TColStd_HArray1OfTransient_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray1OfTransient >":
    return _TColStd.Handle_TColStd_HArray1OfTransient_DownCast(t)

def Handle_TColStd_HArray1OfTransient_IsNull(t: "opencascade::handle< TColStd_HArray1OfTransient > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray1OfTransient_IsNull(t)

def Handle_TColStd_HArray1OfByte_Create() -> "opencascade::handle< TColStd_HArray1OfByte >":
    return _TColStd.Handle_TColStd_HArray1OfByte_Create()

def Handle_TColStd_HArray1OfByte_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray1OfByte >":
    return _TColStd.Handle_TColStd_HArray1OfByte_DownCast(t)

def Handle_TColStd_HArray1OfByte_IsNull(t: "opencascade::handle< TColStd_HArray1OfByte > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray1OfByte_IsNull(t)

def Handle_TColStd_HArray2OfBoolean_Create() -> "opencascade::handle< TColStd_HArray2OfBoolean >":
    return _TColStd.Handle_TColStd_HArray2OfBoolean_Create()

def Handle_TColStd_HArray2OfBoolean_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray2OfBoolean >":
    return _TColStd.Handle_TColStd_HArray2OfBoolean_DownCast(t)

def Handle_TColStd_HArray2OfBoolean_IsNull(t: "opencascade::handle< TColStd_HArray2OfBoolean > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray2OfBoolean_IsNull(t)

def Handle_TColStd_HArray2OfTransient_Create() -> "opencascade::handle< TColStd_HArray2OfTransient >":
    return _TColStd.Handle_TColStd_HArray2OfTransient_Create()

def Handle_TColStd_HArray2OfTransient_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray2OfTransient >":
    return _TColStd.Handle_TColStd_HArray2OfTransient_DownCast(t)

def Handle_TColStd_HArray2OfTransient_IsNull(t: "opencascade::handle< TColStd_HArray2OfTransient > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray2OfTransient_IsNull(t)

def Handle_TColStd_HArray2OfReal_Create() -> "opencascade::handle< TColStd_HArray2OfReal >":
    return _TColStd.Handle_TColStd_HArray2OfReal_Create()

def Handle_TColStd_HArray2OfReal_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray2OfReal >":
    return _TColStd.Handle_TColStd_HArray2OfReal_DownCast(t)

def Handle_TColStd_HArray2OfReal_IsNull(t: "opencascade::handle< TColStd_HArray2OfReal > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray2OfReal_IsNull(t)

def Handle_TColStd_HArray2OfInteger_Create() -> "opencascade::handle< TColStd_HArray2OfInteger >":
    return _TColStd.Handle_TColStd_HArray2OfInteger_Create()

def Handle_TColStd_HArray2OfInteger_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray2OfInteger >":
    return _TColStd.Handle_TColStd_HArray2OfInteger_DownCast(t)

def Handle_TColStd_HArray2OfInteger_IsNull(t: "opencascade::handle< TColStd_HArray2OfInteger > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray2OfInteger_IsNull(t)

def Handle_TColStd_HArray2OfCharacter_Create() -> "opencascade::handle< TColStd_HArray2OfCharacter >":
    return _TColStd.Handle_TColStd_HArray2OfCharacter_Create()

def Handle_TColStd_HArray2OfCharacter_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HArray2OfCharacter >":
    return _TColStd.Handle_TColStd_HArray2OfCharacter_DownCast(t)

def Handle_TColStd_HArray2OfCharacter_IsNull(t: "opencascade::handle< TColStd_HArray2OfCharacter > const &") -> "bool":
    return _TColStd.Handle_TColStd_HArray2OfCharacter_IsNull(t)

def Handle_TColStd_HSequenceOfHAsciiString_Create() -> "opencascade::handle< TColStd_HSequenceOfHAsciiString >":
    return _TColStd.Handle_TColStd_HSequenceOfHAsciiString_Create()

def Handle_TColStd_HSequenceOfHAsciiString_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HSequenceOfHAsciiString >":
    return _TColStd.Handle_TColStd_HSequenceOfHAsciiString_DownCast(t)

def Handle_TColStd_HSequenceOfHAsciiString_IsNull(t: "opencascade::handle< TColStd_HSequenceOfHAsciiString > const &") -> "bool":
    return _TColStd.Handle_TColStd_HSequenceOfHAsciiString_IsNull(t)

def Handle_TColStd_HSequenceOfTransient_Create() -> "opencascade::handle< TColStd_HSequenceOfTransient >":
    return _TColStd.Handle_TColStd_HSequenceOfTransient_Create()

def Handle_TColStd_HSequenceOfTransient_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HSequenceOfTransient >":
    return _TColStd.Handle_TColStd_HSequenceOfTransient_DownCast(t)

def Handle_TColStd_HSequenceOfTransient_IsNull(t: "opencascade::handle< TColStd_HSequenceOfTransient > const &") -> "bool":
    return _TColStd.Handle_TColStd_HSequenceOfTransient_IsNull(t)

def Handle_TColStd_HSequenceOfAsciiString_Create() -> "opencascade::handle< TColStd_HSequenceOfAsciiString >":
    return _TColStd.Handle_TColStd_HSequenceOfAsciiString_Create()

def Handle_TColStd_HSequenceOfAsciiString_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HSequenceOfAsciiString >":
    return _TColStd.Handle_TColStd_HSequenceOfAsciiString_DownCast(t)

def Handle_TColStd_HSequenceOfAsciiString_IsNull(t: "opencascade::handle< TColStd_HSequenceOfAsciiString > const &") -> "bool":
    return _TColStd.Handle_TColStd_HSequenceOfAsciiString_IsNull(t)

def Handle_TColStd_HSequenceOfHExtendedString_Create() -> "opencascade::handle< TColStd_HSequenceOfHExtendedString >":
    return _TColStd.Handle_TColStd_HSequenceOfHExtendedString_Create()

def Handle_TColStd_HSequenceOfHExtendedString_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HSequenceOfHExtendedString >":
    return _TColStd.Handle_TColStd_HSequenceOfHExtendedString_DownCast(t)

def Handle_TColStd_HSequenceOfHExtendedString_IsNull(t: "opencascade::handle< TColStd_HSequenceOfHExtendedString > const &") -> "bool":
    return _TColStd.Handle_TColStd_HSequenceOfHExtendedString_IsNull(t)

def Handle_TColStd_HSequenceOfInteger_Create() -> "opencascade::handle< TColStd_HSequenceOfInteger >":
    return _TColStd.Handle_TColStd_HSequenceOfInteger_Create()

def Handle_TColStd_HSequenceOfInteger_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HSequenceOfInteger >":
    return _TColStd.Handle_TColStd_HSequenceOfInteger_DownCast(t)

def Handle_TColStd_HSequenceOfInteger_IsNull(t: "opencascade::handle< TColStd_HSequenceOfInteger > const &") -> "bool":
    return _TColStd.Handle_TColStd_HSequenceOfInteger_IsNull(t)

def Handle_TColStd_HSequenceOfExtendedString_Create() -> "opencascade::handle< TColStd_HSequenceOfExtendedString >":
    return _TColStd.Handle_TColStd_HSequenceOfExtendedString_Create()

def Handle_TColStd_HSequenceOfExtendedString_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HSequenceOfExtendedString >":
    return _TColStd.Handle_TColStd_HSequenceOfExtendedString_DownCast(t)

def Handle_TColStd_HSequenceOfExtendedString_IsNull(t: "opencascade::handle< TColStd_HSequenceOfExtendedString > const &") -> "bool":
    return _TColStd.Handle_TColStd_HSequenceOfExtendedString_IsNull(t)

def Handle_TColStd_HSequenceOfReal_Create() -> "opencascade::handle< TColStd_HSequenceOfReal >":
    return _TColStd.Handle_TColStd_HSequenceOfReal_Create()

def Handle_TColStd_HSequenceOfReal_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColStd_HSequenceOfReal >":
    return _TColStd.Handle_TColStd_HSequenceOfReal_DownCast(t)

def Handle_TColStd_HSequenceOfReal_IsNull(t: "opencascade::handle< TColStd_HSequenceOfReal > const &") -> "bool":
    return _TColStd.Handle_TColStd_HSequenceOfReal_IsNull(t)
class TColStd_Array1OfAsciiString(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< TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_Array1OfAsciiString_begin(self)

    def end(self) -> "NCollection_Array1< TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_Array1OfAsciiString_end(self)

    def cbegin(self) -> "NCollection_Array1< TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_Array1OfAsciiString_cbegin(self)

    def cend(self) -> "NCollection_Array1< TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_Array1OfAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfAsciiString_swiginit(self, _TColStd.new_TColStd_Array1OfAsciiString(*args))

    def Init(self, theValue: "TCollection_AsciiString") -> "void":
        return _TColStd.TColStd_Array1OfAsciiString_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfAsciiString_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfAsciiString_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfAsciiString_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfAsciiString_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfAsciiString_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfAsciiString_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfAsciiString_IsAllocated(self)

    def Assign(self, theOther: "TColStd_Array1OfAsciiString") -> "NCollection_Array1< TCollection_AsciiString > &":
        return _TColStd.TColStd_Array1OfAsciiString_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array1OfAsciiString") -> "NCollection_Array1< TCollection_AsciiString > &":
        return _TColStd.TColStd_Array1OfAsciiString_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< TCollection_AsciiString > &":
        return _TColStd.TColStd_Array1OfAsciiString_Set(self, *args)

    def First(self) -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_Array1OfAsciiString_First(self)

    def ChangeFirst(self) -> "TCollection_AsciiString &":
        return _TColStd.TColStd_Array1OfAsciiString_ChangeFirst(self)

    def Last(self) -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_Array1OfAsciiString_Last(self)

    def ChangeLast(self) -> "TCollection_AsciiString &":
        return _TColStd.TColStd_Array1OfAsciiString_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_Array1OfAsciiString_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "TCollection_AsciiString &":
        return _TColStd.TColStd_Array1OfAsciiString_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "TCollection_AsciiString &":
        return _TColStd.TColStd_Array1OfAsciiString___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "TCollection_AsciiString") -> "void":
        return _TColStd.TColStd_Array1OfAsciiString_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColStd.TColStd_Array1OfAsciiString_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfAsciiString

    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 TColStd_Array1OfAsciiString in _TColStd:
_TColStd.TColStd_Array1OfAsciiString_swigregister(TColStd_Array1OfAsciiString)

class TColStd_Array1OfBoolean(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< bool >::iterator":
        return _TColStd.TColStd_Array1OfBoolean_begin(self)

    def end(self) -> "NCollection_Array1< bool >::iterator":
        return _TColStd.TColStd_Array1OfBoolean_end(self)

    def cbegin(self) -> "NCollection_Array1< bool >::const_iterator":
        return _TColStd.TColStd_Array1OfBoolean_cbegin(self)

    def cend(self) -> "NCollection_Array1< bool >::const_iterator":
        return _TColStd.TColStd_Array1OfBoolean_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfBoolean_swiginit(self, _TColStd.new_TColStd_Array1OfBoolean(*args))

    def Init(self, theValue: "bool const &") -> "void":
        return _TColStd.TColStd_Array1OfBoolean_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfBoolean_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfBoolean_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfBoolean_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfBoolean_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfBoolean_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfBoolean_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfBoolean_IsAllocated(self)

    def Assign(self, theOther: "TColStd_Array1OfBoolean") -> "NCollection_Array1< Standard_Boolean > &":
        return _TColStd.TColStd_Array1OfBoolean_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array1OfBoolean") -> "NCollection_Array1< Standard_Boolean > &":
        return _TColStd.TColStd_Array1OfBoolean_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< Standard_Boolean > &":
        return _TColStd.TColStd_Array1OfBoolean_Set(self, *args)

    def First(self) -> "bool const &":
        return _TColStd.TColStd_Array1OfBoolean_First(self)

    def ChangeFirst(self) -> "bool &":
        return _TColStd.TColStd_Array1OfBoolean_ChangeFirst(self)

    def Last(self) -> "bool const &":
        return _TColStd.TColStd_Array1OfBoolean_Last(self)

    def ChangeLast(self) -> "bool &":
        return _TColStd.TColStd_Array1OfBoolean_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "bool const &":
        return _TColStd.TColStd_Array1OfBoolean_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "bool &":
        return _TColStd.TColStd_Array1OfBoolean_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "bool &":
        return _TColStd.TColStd_Array1OfBoolean___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "bool const &") -> "void":
        return _TColStd.TColStd_Array1OfBoolean_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColStd.TColStd_Array1OfBoolean_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfBoolean

    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 TColStd_Array1OfBoolean in _TColStd:
_TColStd.TColStd_Array1OfBoolean_swigregister(TColStd_Array1OfBoolean)

class TColStd_Array1OfByte(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< unsigned char >::iterator":
        return _TColStd.TColStd_Array1OfByte_begin(self)

    def end(self) -> "NCollection_Array1< unsigned char >::iterator":
        return _TColStd.TColStd_Array1OfByte_end(self)

    def cbegin(self) -> "NCollection_Array1< unsigned char >::const_iterator":
        return _TColStd.TColStd_Array1OfByte_cbegin(self)

    def cend(self) -> "NCollection_Array1< unsigned char >::const_iterator":
        return _TColStd.TColStd_Array1OfByte_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfByte_swiginit(self, _TColStd.new_TColStd_Array1OfByte(*args))

    def Init(self, theValue: "unsigned char const &") -> "void":
        return _TColStd.TColStd_Array1OfByte_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfByte_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfByte_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfByte_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfByte_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfByte_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfByte_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfByte_IsAllocated(self)

    def Assign(self, theOther: "TColStd_Array1OfByte") -> "NCollection_Array1< Standard_Byte > &":
        return _TColStd.TColStd_Array1OfByte_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array1OfByte") -> "NCollection_Array1< Standard_Byte > &":
        return _TColStd.TColStd_Array1OfByte_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< Standard_Byte > &":
        return _TColStd.TColStd_Array1OfByte_Set(self, *args)

    def First(self) -> "unsigned char const &":
        return _TColStd.TColStd_Array1OfByte_First(self)

    def ChangeFirst(self) -> "unsigned char &":
        return _TColStd.TColStd_Array1OfByte_ChangeFirst(self)

    def Last(self) -> "unsigned char const &":
        return _TColStd.TColStd_Array1OfByte_Last(self)

    def ChangeLast(self) -> "unsigned char &":
        return _TColStd.TColStd_Array1OfByte_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "unsigned char const &":
        return _TColStd.TColStd_Array1OfByte_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "unsigned char &":
        return _TColStd.TColStd_Array1OfByte_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "unsigned char &":
        return _TColStd.TColStd_Array1OfByte___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "unsigned char const &") -> "void":
        return _TColStd.TColStd_Array1OfByte_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColStd.TColStd_Array1OfByte_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfByte

    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 TColStd_Array1OfByte in _TColStd:
_TColStd.TColStd_Array1OfByte_swigregister(TColStd_Array1OfByte)

class TColStd_Array1OfCharacter(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< char >::iterator":
        return _TColStd.TColStd_Array1OfCharacter_begin(self)

    def end(self) -> "NCollection_Array1< char >::iterator":
        return _TColStd.TColStd_Array1OfCharacter_end(self)

    def cbegin(self) -> "NCollection_Array1< char >::const_iterator":
        return _TColStd.TColStd_Array1OfCharacter_cbegin(self)

    def cend(self) -> "NCollection_Array1< char >::const_iterator":
        return _TColStd.TColStd_Array1OfCharacter_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfCharacter_swiginit(self, _TColStd.new_TColStd_Array1OfCharacter(*args))

    def Init(self, theValue: "char const &") -> "void":
        return _TColStd.TColStd_Array1OfCharacter_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfCharacter_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfCharacter_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfCharacter_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfCharacter_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfCharacter_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfCharacter_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfCharacter_IsAllocated(self)

    def Assign(self, theOther: "TColStd_Array1OfCharacter") -> "NCollection_Array1< Standard_Character > &":
        return _TColStd.TColStd_Array1OfCharacter_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array1OfCharacter") -> "NCollection_Array1< Standard_Character > &":
        return _TColStd.TColStd_Array1OfCharacter_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< Standard_Character > &":
        return _TColStd.TColStd_Array1OfCharacter_Set(self, *args)

    def First(self) -> "char const &":
        return _TColStd.TColStd_Array1OfCharacter_First(self)

    def ChangeFirst(self) -> "char &":
        return _TColStd.TColStd_Array1OfCharacter_ChangeFirst(self)

    def Last(self) -> "char const &":
        return _TColStd.TColStd_Array1OfCharacter_Last(self)

    def ChangeLast(self) -> "char &":
        return _TColStd.TColStd_Array1OfCharacter_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "char const &":
        return _TColStd.TColStd_Array1OfCharacter_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "char &":
        return _TColStd.TColStd_Array1OfCharacter_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "char &":
        return _TColStd.TColStd_Array1OfCharacter___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "char const &") -> "void":
        return _TColStd.TColStd_Array1OfCharacter_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColStd.TColStd_Array1OfCharacter_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfCharacter

    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 TColStd_Array1OfCharacter in _TColStd:
_TColStd.TColStd_Array1OfCharacter_swigregister(TColStd_Array1OfCharacter)

class TColStd_Array1OfExtendedString(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< TCollection_ExtendedString >::iterator":
        return _TColStd.TColStd_Array1OfExtendedString_begin(self)

    def end(self) -> "NCollection_Array1< TCollection_ExtendedString >::iterator":
        return _TColStd.TColStd_Array1OfExtendedString_end(self)

    def cbegin(self) -> "NCollection_Array1< TCollection_ExtendedString >::const_iterator":
        return _TColStd.TColStd_Array1OfExtendedString_cbegin(self)

    def cend(self) -> "NCollection_Array1< TCollection_ExtendedString >::const_iterator":
        return _TColStd.TColStd_Array1OfExtendedString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfExtendedString_swiginit(self, _TColStd.new_TColStd_Array1OfExtendedString(*args))

    def Init(self, theValue: "TCollection_ExtendedString") -> "void":
        return _TColStd.TColStd_Array1OfExtendedString_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfExtendedString_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfExtendedString_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfExtendedString_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfExtendedString_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfExtendedString_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfExtendedString_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfExtendedString_IsAllocated(self)

    def Assign(self, theOther: "TColStd_Array1OfExtendedString") -> "NCollection_Array1< TCollection_ExtendedString > &":
        return _TColStd.TColStd_Array1OfExtendedString_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array1OfExtendedString") -> "NCollection_Array1< TCollection_ExtendedString > &":
        return _TColStd.TColStd_Array1OfExtendedString_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< TCollection_ExtendedString > &":
        return _TColStd.TColStd_Array1OfExtendedString_Set(self, *args)

    def First(self) -> "TCollection_ExtendedString const &":
        return _TColStd.TColStd_Array1OfExtendedString_First(self)

    def ChangeFirst(self) -> "TCollection_ExtendedString &":
        return _TColStd.TColStd_Array1OfExtendedString_ChangeFirst(self)

    def Last(self) -> "TCollection_ExtendedString const &":
        return _TColStd.TColStd_Array1OfExtendedString_Last(self)

    def ChangeLast(self) -> "TCollection_ExtendedString &":
        return _TColStd.TColStd_Array1OfExtendedString_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "TCollection_ExtendedString const &":
        return _TColStd.TColStd_Array1OfExtendedString_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "TCollection_ExtendedString &":
        return _TColStd.TColStd_Array1OfExtendedString_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "TCollection_ExtendedString &":
        return _TColStd.TColStd_Array1OfExtendedString___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "TCollection_ExtendedString") -> "void":
        return _TColStd.TColStd_Array1OfExtendedString_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColStd.TColStd_Array1OfExtendedString_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfExtendedString

    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 TColStd_Array1OfExtendedString in _TColStd:
_TColStd.TColStd_Array1OfExtendedString_swigregister(TColStd_Array1OfExtendedString)

class TColStd_Array1OfInteger(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< int >::iterator":
        return _TColStd.TColStd_Array1OfInteger_begin(self)

    def end(self) -> "NCollection_Array1< int >::iterator":
        return _TColStd.TColStd_Array1OfInteger_end(self)

    def cbegin(self) -> "NCollection_Array1< int >::const_iterator":
        return _TColStd.TColStd_Array1OfInteger_cbegin(self)

    def cend(self) -> "NCollection_Array1< int >::const_iterator":
        return _TColStd.TColStd_Array1OfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfInteger_swiginit(self, _TColStd.new_TColStd_Array1OfInteger(*args))

    def Init(self, theValue: "int const &") -> "void":
        return _TColStd.TColStd_Array1OfInteger_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfInteger_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfInteger_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfInteger_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfInteger_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfInteger_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfInteger_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfInteger_IsAllocated(self)

    def Assign(self, theOther: "TColStd_Array1OfInteger") -> "NCollection_Array1< Standard_Integer > &":
        return _TColStd.TColStd_Array1OfInteger_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array1OfInteger") -> "NCollection_Array1< Standard_Integer > &":
        return _TColStd.TColStd_Array1OfInteger_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< Standard_Integer > &":
        return _TColStd.TColStd_Array1OfInteger_Set(self, *args)

    def First(self) -> "int const &":
        return _TColStd.TColStd_Array1OfInteger_First(self)

    def ChangeFirst(self) -> "int &":
        return _TColStd.TColStd_Array1OfInteger_ChangeFirst(self)

    def Last(self) -> "int const &":
        return _TColStd.TColStd_Array1OfInteger_Last(self)

    def ChangeLast(self) -> "int &":
        return _TColStd.TColStd_Array1OfInteger_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "int const &":
        return _TColStd.TColStd_Array1OfInteger_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "int &":
        return _TColStd.TColStd_Array1OfInteger_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "int &":
        return _TColStd.TColStd_Array1OfInteger___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "int const &") -> "void":
        return _TColStd.TColStd_Array1OfInteger_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColStd.TColStd_Array1OfInteger_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfInteger

    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 TColStd_Array1OfInteger in _TColStd:
_TColStd.TColStd_Array1OfInteger_swigregister(TColStd_Array1OfInteger)

class TColStd_Array1OfListOfInteger(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< TColStd_ListOfInteger >::iterator":
        return _TColStd.TColStd_Array1OfListOfInteger_begin(self)

    def end(self) -> "NCollection_Array1< TColStd_ListOfInteger >::iterator":
        return _TColStd.TColStd_Array1OfListOfInteger_end(self)

    def cbegin(self) -> "NCollection_Array1< TColStd_ListOfInteger >::const_iterator":
        return _TColStd.TColStd_Array1OfListOfInteger_cbegin(self)

    def cend(self) -> "NCollection_Array1< TColStd_ListOfInteger >::const_iterator":
        return _TColStd.TColStd_Array1OfListOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfListOfInteger_swiginit(self, _TColStd.new_TColStd_Array1OfListOfInteger(*args))

    def Init(self, theValue: "TColStd_ListOfInteger") -> "void":
        return _TColStd.TColStd_Array1OfListOfInteger_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfListOfInteger_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfListOfInteger_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfListOfInteger_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfListOfInteger_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfListOfInteger_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfListOfInteger_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfListOfInteger_IsAllocated(self)

    def Assign(self, theOther: "TColStd_Array1OfListOfInteger") -> "NCollection_Array1< TColStd_ListOfInteger > &":
        return _TColStd.TColStd_Array1OfListOfInteger_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array1OfListOfInteger") -> "NCollection_Array1< TColStd_ListOfInteger > &":
        return _TColStd.TColStd_Array1OfListOfInteger_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< TColStd_ListOfInteger > &":
        return _TColStd.TColStd_Array1OfListOfInteger_Set(self, *args)

    def First(self) -> "TColStd_ListOfInteger const &":
        return _TColStd.TColStd_Array1OfListOfInteger_First(self)

    def ChangeFirst(self) -> "TColStd_ListOfInteger &":
        return _TColStd.TColStd_Array1OfListOfInteger_ChangeFirst(self)

    def Last(self) -> "TColStd_ListOfInteger const &":
        return _TColStd.TColStd_Array1OfListOfInteger_Last(self)

    def ChangeLast(self) -> "TColStd_ListOfInteger &":
        return _TColStd.TColStd_Array1OfListOfInteger_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "TColStd_ListOfInteger const &":
        return _TColStd.TColStd_Array1OfListOfInteger_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "TColStd_ListOfInteger &":
        return _TColStd.TColStd_Array1OfListOfInteger_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "TColStd_ListOfInteger &":
        return _TColStd.TColStd_Array1OfListOfInteger___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "TColStd_ListOfInteger") -> "void":
        return _TColStd.TColStd_Array1OfListOfInteger_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColStd.TColStd_Array1OfListOfInteger_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfListOfInteger

    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 TColStd_Array1OfListOfInteger in _TColStd:
_TColStd.TColStd_Array1OfListOfInteger_swigregister(TColStd_Array1OfListOfInteger)

class TColStd_Array1OfReal(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< double >::iterator":
        return _TColStd.TColStd_Array1OfReal_begin(self)

    def end(self) -> "NCollection_Array1< double >::iterator":
        return _TColStd.TColStd_Array1OfReal_end(self)

    def cbegin(self) -> "NCollection_Array1< double >::const_iterator":
        return _TColStd.TColStd_Array1OfReal_cbegin(self)

    def cend(self) -> "NCollection_Array1< double >::const_iterator":
        return _TColStd.TColStd_Array1OfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfReal_swiginit(self, _TColStd.new_TColStd_Array1OfReal(*args))

    def Init(self, theValue: "double const &") -> "void":
        return _TColStd.TColStd_Array1OfReal_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfReal_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfReal_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfReal_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfReal_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfReal_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfReal_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfReal_IsAllocated(self)

    def Assign(self, theOther: "TColStd_Array1OfReal") -> "NCollection_Array1< Standard_Real > &":
        return _TColStd.TColStd_Array1OfReal_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array1OfReal") -> "NCollection_Array1< Standard_Real > &":
        return _TColStd.TColStd_Array1OfReal_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< Standard_Real > &":
        return _TColStd.TColStd_Array1OfReal_Set(self, *args)

    def First(self) -> "double const &":
        return _TColStd.TColStd_Array1OfReal_First(self)

    def ChangeFirst(self) -> "double &":
        return _TColStd.TColStd_Array1OfReal_ChangeFirst(self)

    def Last(self) -> "double const &":
        return _TColStd.TColStd_Array1OfReal_Last(self)

    def ChangeLast(self) -> "double &":
        return _TColStd.TColStd_Array1OfReal_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "double const &":
        return _TColStd.TColStd_Array1OfReal_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "double &":
        return _TColStd.TColStd_Array1OfReal_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "double &":
        return _TColStd.TColStd_Array1OfReal___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "double const &") -> "void":
        return _TColStd.TColStd_Array1OfReal_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColStd.TColStd_Array1OfReal_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfReal

    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 TColStd_Array1OfReal in _TColStd:
_TColStd.TColStd_Array1OfReal_swigregister(TColStd_Array1OfReal)

class TColStd_Array1OfTransient(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< opencascade::handle< Standard_Transient > >::iterator":
        return _TColStd.TColStd_Array1OfTransient_begin(self)

    def end(self) -> "NCollection_Array1< opencascade::handle< Standard_Transient > >::iterator":
        return _TColStd.TColStd_Array1OfTransient_end(self)

    def cbegin(self) -> "NCollection_Array1< opencascade::handle< Standard_Transient > >::const_iterator":
        return _TColStd.TColStd_Array1OfTransient_cbegin(self)

    def cend(self) -> "NCollection_Array1< opencascade::handle< Standard_Transient > >::const_iterator":
        return _TColStd.TColStd_Array1OfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfTransient_swiginit(self, _TColStd.new_TColStd_Array1OfTransient(*args))

    def Init(self, theValue: "opencascade::handle< Standard_Transient > const &") -> "void":
        return _TColStd.TColStd_Array1OfTransient_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfTransient_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfTransient_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfTransient_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfTransient_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array1OfTransient_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfTransient_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array1OfTransient_IsAllocated(self)

    def Assign(self, theOther: "TColStd_Array1OfTransient") -> "NCollection_Array1< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_Array1OfTransient_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array1OfTransient") -> "NCollection_Array1< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_Array1OfTransient_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_Array1OfTransient_Set(self, *args)

    def First(self) -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_Array1OfTransient_First(self)

    def ChangeFirst(self) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_Array1OfTransient_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_Array1OfTransient_Last(self)

    def ChangeLast(self) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_Array1OfTransient_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_Array1OfTransient_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_Array1OfTransient_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_Array1OfTransient___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< Standard_Transient > const &") -> "void":
        return _TColStd.TColStd_Array1OfTransient_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColStd.TColStd_Array1OfTransient_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfTransient

    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 TColStd_Array1OfTransient in _TColStd:
_TColStd.TColStd_Array1OfTransient_swigregister(TColStd_Array1OfTransient)

class TColStd_Array2OfBoolean(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):
        _TColStd.TColStd_Array2OfBoolean_swiginit(self, _TColStd.new_TColStd_Array2OfBoolean(*args))

    def Init(self, theValue: "bool const &") -> "void":
        return _TColStd.TColStd_Array2OfBoolean_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfBoolean_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array2OfBoolean_IsDeletable(self)

    def Assign(self, theOther: "TColStd_Array2OfBoolean") -> "NCollection_Array2< Standard_Boolean > &":
        return _TColStd.TColStd_Array2OfBoolean_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array2OfBoolean") -> "NCollection_Array2< Standard_Boolean > &":
        return _TColStd.TColStd_Array2OfBoolean_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< Standard_Boolean > &":
        return _TColStd.TColStd_Array2OfBoolean_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "bool const &":
        return _TColStd.TColStd_Array2OfBoolean_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "bool &":
        return _TColStd.TColStd_Array2OfBoolean_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "bool &":
        return _TColStd.TColStd_Array2OfBoolean___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "bool const &") -> "void":
        return _TColStd.TColStd_Array2OfBoolean_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower: "Standard_Integer", theRowUpper: "Standard_Integer", theColLower: "Standard_Integer", theColUpper: "Standard_Integer", theToCopyData: "Standard_Boolean") -> "void":
        return _TColStd.TColStd_Array2OfBoolean_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfBoolean

# Register TColStd_Array2OfBoolean in _TColStd:
_TColStd.TColStd_Array2OfBoolean_swigregister(TColStd_Array2OfBoolean)

class TColStd_Array2OfCharacter(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):
        _TColStd.TColStd_Array2OfCharacter_swiginit(self, _TColStd.new_TColStd_Array2OfCharacter(*args))

    def Init(self, theValue: "char const &") -> "void":
        return _TColStd.TColStd_Array2OfCharacter_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfCharacter_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array2OfCharacter_IsDeletable(self)

    def Assign(self, theOther: "TColStd_Array2OfCharacter") -> "NCollection_Array2< Standard_Character > &":
        return _TColStd.TColStd_Array2OfCharacter_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array2OfCharacter") -> "NCollection_Array2< Standard_Character > &":
        return _TColStd.TColStd_Array2OfCharacter_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< Standard_Character > &":
        return _TColStd.TColStd_Array2OfCharacter_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "char const &":
        return _TColStd.TColStd_Array2OfCharacter_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "char &":
        return _TColStd.TColStd_Array2OfCharacter_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "char &":
        return _TColStd.TColStd_Array2OfCharacter___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "char const &") -> "void":
        return _TColStd.TColStd_Array2OfCharacter_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower: "Standard_Integer", theRowUpper: "Standard_Integer", theColLower: "Standard_Integer", theColUpper: "Standard_Integer", theToCopyData: "Standard_Boolean") -> "void":
        return _TColStd.TColStd_Array2OfCharacter_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfCharacter

# Register TColStd_Array2OfCharacter in _TColStd:
_TColStd.TColStd_Array2OfCharacter_swigregister(TColStd_Array2OfCharacter)

class TColStd_Array2OfInteger(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):
        _TColStd.TColStd_Array2OfInteger_swiginit(self, _TColStd.new_TColStd_Array2OfInteger(*args))

    def Init(self, theValue: "int const &") -> "void":
        return _TColStd.TColStd_Array2OfInteger_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfInteger_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array2OfInteger_IsDeletable(self)

    def Assign(self, theOther: "TColStd_Array2OfInteger") -> "NCollection_Array2< Standard_Integer > &":
        return _TColStd.TColStd_Array2OfInteger_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array2OfInteger") -> "NCollection_Array2< Standard_Integer > &":
        return _TColStd.TColStd_Array2OfInteger_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< Standard_Integer > &":
        return _TColStd.TColStd_Array2OfInteger_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "int const &":
        return _TColStd.TColStd_Array2OfInteger_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "int &":
        return _TColStd.TColStd_Array2OfInteger_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "int &":
        return _TColStd.TColStd_Array2OfInteger___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "int const &") -> "void":
        return _TColStd.TColStd_Array2OfInteger_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower: "Standard_Integer", theRowUpper: "Standard_Integer", theColLower: "Standard_Integer", theColUpper: "Standard_Integer", theToCopyData: "Standard_Boolean") -> "void":
        return _TColStd.TColStd_Array2OfInteger_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfInteger

# Register TColStd_Array2OfInteger in _TColStd:
_TColStd.TColStd_Array2OfInteger_swigregister(TColStd_Array2OfInteger)

class TColStd_Array2OfReal(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):
        _TColStd.TColStd_Array2OfReal_swiginit(self, _TColStd.new_TColStd_Array2OfReal(*args))

    def Init(self, theValue: "double const &") -> "void":
        return _TColStd.TColStd_Array2OfReal_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfReal_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array2OfReal_IsDeletable(self)

    def Assign(self, theOther: "TColStd_Array2OfReal") -> "NCollection_Array2< Standard_Real > &":
        return _TColStd.TColStd_Array2OfReal_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array2OfReal") -> "NCollection_Array2< Standard_Real > &":
        return _TColStd.TColStd_Array2OfReal_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< Standard_Real > &":
        return _TColStd.TColStd_Array2OfReal_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "double const &":
        return _TColStd.TColStd_Array2OfReal_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "double &":
        return _TColStd.TColStd_Array2OfReal_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "double &":
        return _TColStd.TColStd_Array2OfReal___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "double const &") -> "void":
        return _TColStd.TColStd_Array2OfReal_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower: "Standard_Integer", theRowUpper: "Standard_Integer", theColLower: "Standard_Integer", theColUpper: "Standard_Integer", theToCopyData: "Standard_Boolean") -> "void":
        return _TColStd.TColStd_Array2OfReal_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfReal

# Register TColStd_Array2OfReal in _TColStd:
_TColStd.TColStd_Array2OfReal_swigregister(TColStd_Array2OfReal)

class TColStd_Array2OfTransient(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):
        _TColStd.TColStd_Array2OfTransient_swiginit(self, _TColStd.new_TColStd_Array2OfTransient(*args))

    def Init(self, theValue: "opencascade::handle< Standard_Transient > const &") -> "void":
        return _TColStd.TColStd_Array2OfTransient_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColStd.TColStd_Array2OfTransient_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColStd.TColStd_Array2OfTransient_IsDeletable(self)

    def Assign(self, theOther: "TColStd_Array2OfTransient") -> "NCollection_Array2< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_Array2OfTransient_Assign(self, theOther)

    def Move(self, theOther: "TColStd_Array2OfTransient") -> "NCollection_Array2< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_Array2OfTransient_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_Array2OfTransient_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_Array2OfTransient_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_Array2OfTransient_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_Array2OfTransient___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "opencascade::handle< Standard_Transient > const &") -> "void":
        return _TColStd.TColStd_Array2OfTransient_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower: "Standard_Integer", theRowUpper: "Standard_Integer", theColLower: "Standard_Integer", theColUpper: "Standard_Integer", theToCopyData: "Standard_Boolean") -> "void":
        return _TColStd.TColStd_Array2OfTransient_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfTransient

# Register TColStd_Array2OfTransient in _TColStd:
_TColStd.TColStd_Array2OfTransient_swigregister(TColStd_Array2OfTransient)

class TColStd_DataMapOfAsciiStringInteger(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< TCollection_AsciiString,int,TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_begin(self)

    def end(self) -> "NCollection_DataMap< TCollection_AsciiString,int,TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< TCollection_AsciiString,int,TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< TCollection_AsciiString,int,TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfAsciiStringInteger_swiginit(self, _TColStd.new_TColStd_DataMapOfAsciiStringInteger(*args))

    def Exchange(self, theOther: "TColStd_DataMapOfAsciiStringInteger") -> "void":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_DataMapOfAsciiStringInteger") -> "NCollection_DataMap< TCollection_AsciiString,Standard_Integer,TCollection_AsciiString > &":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Assign(self, theOther)

    def Set(self, theOther: "TColStd_DataMapOfAsciiStringInteger") -> "NCollection_DataMap< TCollection_AsciiString,Standard_Integer,TCollection_AsciiString > &":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Set(self, theOther)

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

    def Bind(self, theKey: "TCollection_AsciiString", theItem: "int const &") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "TCollection_AsciiString", theItem: "int const &") -> "int *":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "TCollection_AsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_IsBound(self, theKey)

    def UnBind(self, theKey: "TCollection_AsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_UnBind(self, theKey)

    def Seek(self, theKey: "TCollection_AsciiString") -> "int const *":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "TCollection_AsciiString") -> "int *":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "TCollection_AsciiString") -> "int &":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_ChangeFind(self, theKey)

    def __call__(self, *args) -> "int &":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfAsciiStringInteger

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Size(self)

# Register TColStd_DataMapOfAsciiStringInteger in _TColStd:
_TColStd.TColStd_DataMapOfAsciiStringInteger_swigregister(TColStd_DataMapOfAsciiStringInteger)

class TColStd_DataMapOfIntegerInteger(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,int,TColStd_MapIntegerHasher >::iterator":
        return _TColStd.TColStd_DataMapOfIntegerInteger_begin(self)

    def end(self) -> "NCollection_DataMap< int,int,TColStd_MapIntegerHasher >::iterator":
        return _TColStd.TColStd_DataMapOfIntegerInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,int,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfIntegerInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,int,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfIntegerInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfIntegerInteger_swiginit(self, _TColStd.new_TColStd_DataMapOfIntegerInteger(*args))

    def Exchange(self, theOther: "TColStd_DataMapOfIntegerInteger") -> "void":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_DataMapOfIntegerInteger") -> "NCollection_DataMap< Standard_Integer,Standard_Integer,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Assign(self, theOther)

    def Set(self, theOther: "TColStd_DataMapOfIntegerInteger") -> "NCollection_DataMap< Standard_Integer,Standard_Integer,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "int const &") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "int const &") -> "int *":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "int const *":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "int *":
        return _TColStd.TColStd_DataMapOfIntegerInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "int &":
        return _TColStd.TColStd_DataMapOfIntegerInteger_ChangeFind(self, theKey)

    def __call__(self, *args) -> "int &":
        return _TColStd.TColStd_DataMapOfIntegerInteger___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfIntegerInteger

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Size(self)

    def Keys(self) -> "PyObject *":
        return _TColStd.TColStd_DataMapOfIntegerInteger_Keys(self)

# Register TColStd_DataMapOfIntegerInteger in _TColStd:
_TColStd.TColStd_DataMapOfIntegerInteger_swigregister(TColStd_DataMapOfIntegerInteger)

class TColStd_DataMapOfIntegerListOfInteger(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,TColStd_ListOfInteger,TColStd_MapIntegerHasher >::iterator":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_begin(self)

    def end(self) -> "NCollection_DataMap< int,TColStd_ListOfInteger,TColStd_MapIntegerHasher >::iterator":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,TColStd_ListOfInteger,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,TColStd_ListOfInteger,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfIntegerListOfInteger_swiginit(self, _TColStd.new_TColStd_DataMapOfIntegerListOfInteger(*args))

    def Exchange(self, theOther: "TColStd_DataMapOfIntegerListOfInteger") -> "void":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_DataMapOfIntegerListOfInteger") -> "NCollection_DataMap< Standard_Integer,TColStd_ListOfInteger,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Assign(self, theOther)

    def Set(self, theOther: "TColStd_DataMapOfIntegerListOfInteger") -> "NCollection_DataMap< Standard_Integer,TColStd_ListOfInteger,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "TColStd_ListOfInteger") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "TColStd_ListOfInteger") -> "TColStd_ListOfInteger *":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "TColStd_ListOfInteger const *":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "TColStd_ListOfInteger *":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "TColStd_ListOfInteger &":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args) -> "TColStd_ListOfInteger &":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfIntegerListOfInteger

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Size(self)

    def Keys(self) -> "PyObject *":
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Keys(self)

# Register TColStd_DataMapOfIntegerListOfInteger in _TColStd:
_TColStd.TColStd_DataMapOfIntegerListOfInteger_swigregister(TColStd_DataMapOfIntegerListOfInteger)

class TColStd_DataMapOfIntegerReal(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,double,TColStd_MapIntegerHasher >::iterator":
        return _TColStd.TColStd_DataMapOfIntegerReal_begin(self)

    def end(self) -> "NCollection_DataMap< int,double,TColStd_MapIntegerHasher >::iterator":
        return _TColStd.TColStd_DataMapOfIntegerReal_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,double,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfIntegerReal_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,double,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfIntegerReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfIntegerReal_swiginit(self, _TColStd.new_TColStd_DataMapOfIntegerReal(*args))

    def Exchange(self, theOther: "TColStd_DataMapOfIntegerReal") -> "void":
        return _TColStd.TColStd_DataMapOfIntegerReal_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_DataMapOfIntegerReal") -> "NCollection_DataMap< Standard_Integer,Standard_Real,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_DataMapOfIntegerReal_Assign(self, theOther)

    def Set(self, theOther: "TColStd_DataMapOfIntegerReal") -> "NCollection_DataMap< Standard_Integer,Standard_Real,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_DataMapOfIntegerReal_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "double const &") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfIntegerReal_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "double const &") -> "double *":
        return _TColStd.TColStd_DataMapOfIntegerReal_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "double const *":
        return _TColStd.TColStd_DataMapOfIntegerReal_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfIntegerReal_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "double *":
        return _TColStd.TColStd_DataMapOfIntegerReal_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "double &":
        return _TColStd.TColStd_DataMapOfIntegerReal_ChangeFind(self, theKey)

    def __call__(self, *args) -> "double &":
        return _TColStd.TColStd_DataMapOfIntegerReal___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_DataMapOfIntegerReal_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfIntegerReal

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_DataMapOfIntegerReal_Size(self)

    def Keys(self) -> "PyObject *":
        return _TColStd.TColStd_DataMapOfIntegerReal_Keys(self)

# Register TColStd_DataMapOfIntegerReal in _TColStd:
_TColStd.TColStd_DataMapOfIntegerReal_swigregister(TColStd_DataMapOfIntegerReal)

class TColStd_DataMapOfIntegerTransient(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,opencascade::handle< Standard_Transient >,TColStd_MapIntegerHasher >::iterator":
        return _TColStd.TColStd_DataMapOfIntegerTransient_begin(self)

    def end(self) -> "NCollection_DataMap< int,opencascade::handle< Standard_Transient >,TColStd_MapIntegerHasher >::iterator":
        return _TColStd.TColStd_DataMapOfIntegerTransient_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,opencascade::handle< Standard_Transient >,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfIntegerTransient_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,opencascade::handle< Standard_Transient >,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfIntegerTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfIntegerTransient_swiginit(self, _TColStd.new_TColStd_DataMapOfIntegerTransient(*args))

    def Exchange(self, theOther: "TColStd_DataMapOfIntegerTransient") -> "void":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_DataMapOfIntegerTransient") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< Standard_Transient >,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Assign(self, theOther)

    def Set(self, theOther: "TColStd_DataMapOfIntegerTransient") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< Standard_Transient >,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Standard_Transient > *":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "opencascade::handle< Standard_Transient > const *":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "opencascade::handle< Standard_Transient > *":
        return _TColStd.TColStd_DataMapOfIntegerTransient_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_DataMapOfIntegerTransient_ChangeFind(self, theKey)

    def __call__(self, *args) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_DataMapOfIntegerTransient___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfIntegerTransient

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Size(self)

    def Keys(self) -> "PyObject *":
        return _TColStd.TColStd_DataMapOfIntegerTransient_Keys(self)

# Register TColStd_DataMapOfIntegerTransient in _TColStd:
_TColStd.TColStd_DataMapOfIntegerTransient_swigregister(TColStd_DataMapOfIntegerTransient)

class TColStd_DataMapOfStringInteger(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< TCollection_ExtendedString,int,TCollection_ExtendedString >::iterator":
        return _TColStd.TColStd_DataMapOfStringInteger_begin(self)

    def end(self) -> "NCollection_DataMap< TCollection_ExtendedString,int,TCollection_ExtendedString >::iterator":
        return _TColStd.TColStd_DataMapOfStringInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< TCollection_ExtendedString,int,TCollection_ExtendedString >::const_iterator":
        return _TColStd.TColStd_DataMapOfStringInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< TCollection_ExtendedString,int,TCollection_ExtendedString >::const_iterator":
        return _TColStd.TColStd_DataMapOfStringInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfStringInteger_swiginit(self, _TColStd.new_TColStd_DataMapOfStringInteger(*args))

    def Exchange(self, theOther: "TColStd_DataMapOfStringInteger") -> "void":
        return _TColStd.TColStd_DataMapOfStringInteger_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_DataMapOfStringInteger") -> "NCollection_DataMap< TCollection_ExtendedString,Standard_Integer,TCollection_ExtendedString > &":
        return _TColStd.TColStd_DataMapOfStringInteger_Assign(self, theOther)

    def Set(self, theOther: "TColStd_DataMapOfStringInteger") -> "NCollection_DataMap< TCollection_ExtendedString,Standard_Integer,TCollection_ExtendedString > &":
        return _TColStd.TColStd_DataMapOfStringInteger_Set(self, theOther)

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

    def Bind(self, theKey: "TCollection_ExtendedString", theItem: "int const &") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfStringInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "TCollection_ExtendedString", theItem: "int const &") -> "int *":
        return _TColStd.TColStd_DataMapOfStringInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "TCollection_ExtendedString") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfStringInteger_IsBound(self, theKey)

    def UnBind(self, theKey: "TCollection_ExtendedString") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfStringInteger_UnBind(self, theKey)

    def Seek(self, theKey: "TCollection_ExtendedString") -> "int const *":
        return _TColStd.TColStd_DataMapOfStringInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfStringInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "TCollection_ExtendedString") -> "int *":
        return _TColStd.TColStd_DataMapOfStringInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "TCollection_ExtendedString") -> "int &":
        return _TColStd.TColStd_DataMapOfStringInteger_ChangeFind(self, theKey)

    def __call__(self, *args) -> "int &":
        return _TColStd.TColStd_DataMapOfStringInteger___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_DataMapOfStringInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfStringInteger

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_DataMapOfStringInteger_Size(self)

# Register TColStd_DataMapOfStringInteger in _TColStd:
_TColStd.TColStd_DataMapOfStringInteger_swigregister(TColStd_DataMapOfStringInteger)

class TColStd_DataMapOfTransientTransient(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< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::iterator":
        return _TColStd.TColStd_DataMapOfTransientTransient_begin(self)

    def end(self) -> "NCollection_DataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::iterator":
        return _TColStd.TColStd_DataMapOfTransientTransient_end(self)

    def cbegin(self) -> "NCollection_DataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfTransientTransient_cbegin(self)

    def cend(self) -> "NCollection_DataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::const_iterator":
        return _TColStd.TColStd_DataMapOfTransientTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfTransientTransient_swiginit(self, _TColStd.new_TColStd_DataMapOfTransientTransient(*args))

    def Exchange(self, theOther: "TColStd_DataMapOfTransientTransient") -> "void":
        return _TColStd.TColStd_DataMapOfTransientTransient_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_DataMapOfTransientTransient") -> "NCollection_DataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher > &":
        return _TColStd.TColStd_DataMapOfTransientTransient_Assign(self, theOther)

    def Set(self, theOther: "TColStd_DataMapOfTransientTransient") -> "NCollection_DataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher > &":
        return _TColStd.TColStd_DataMapOfTransientTransient_Set(self, theOther)

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

    def Bind(self, theKey: "opencascade::handle< Standard_Transient > const &", theItem: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfTransientTransient_Bind(self, theKey, theItem)

    def Bound(self, theKey: "opencascade::handle< Standard_Transient > const &", theItem: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Standard_Transient > *":
        return _TColStd.TColStd_DataMapOfTransientTransient_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfTransientTransient_IsBound(self, theKey)

    def UnBind(self, theKey: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfTransientTransient_UnBind(self, theKey)

    def Seek(self, theKey: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Standard_Transient > const *":
        return _TColStd.TColStd_DataMapOfTransientTransient_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_DataMapOfTransientTransient_Find(self, *args)

    def ChangeSeek(self, theKey: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Standard_Transient > *":
        return _TColStd.TColStd_DataMapOfTransientTransient_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_DataMapOfTransientTransient_ChangeFind(self, theKey)

    def __call__(self, *args) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_DataMapOfTransientTransient___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_DataMapOfTransientTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfTransientTransient

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_DataMapOfTransientTransient_Size(self)

# Register TColStd_DataMapOfTransientTransient in _TColStd:
_TColStd.TColStd_DataMapOfTransientTransient_swigregister(TColStd_DataMapOfTransientTransient)

class TColStd_IndexedDataMapOfStringString(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< TCollection_AsciiString,TCollection_AsciiString,TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_IndexedDataMapOfStringString_begin(self)

    def end(self) -> "NCollection_IndexedDataMap< TCollection_AsciiString,TCollection_AsciiString,TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_IndexedDataMapOfStringString_end(self)

    def cbegin(self) -> "NCollection_IndexedDataMap< TCollection_AsciiString,TCollection_AsciiString,TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_IndexedDataMapOfStringString_cbegin(self)

    def cend(self) -> "NCollection_IndexedDataMap< TCollection_AsciiString,TCollection_AsciiString,TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_IndexedDataMapOfStringString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedDataMapOfStringString_swiginit(self, _TColStd.new_TColStd_IndexedDataMapOfStringString(*args))

    def Exchange(self, theOther: "TColStd_IndexedDataMapOfStringString") -> "void":
        return _TColStd.TColStd_IndexedDataMapOfStringString_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_IndexedDataMapOfStringString") -> "NCollection_IndexedDataMap< TCollection_AsciiString,TCollection_AsciiString,TCollection_AsciiString > &":
        return _TColStd.TColStd_IndexedDataMapOfStringString_Assign(self, theOther)

    def Set(self, theOther: "TColStd_IndexedDataMapOfStringString") -> "NCollection_IndexedDataMap< TCollection_AsciiString,TCollection_AsciiString,TCollection_AsciiString > &":
        return _TColStd.TColStd_IndexedDataMapOfStringString_Set(self, theOther)

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

    def Add(self, theKey1: "TCollection_AsciiString", theItem: "TCollection_AsciiString") -> "Standard_Integer":
        return _TColStd.TColStd_IndexedDataMapOfStringString_Add(self, theKey1, theItem)

    def Contains(self, theKey1: "TCollection_AsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_IndexedDataMapOfStringString_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "TCollection_AsciiString", theItem: "TCollection_AsciiString") -> "void":
        return _TColStd.TColStd_IndexedDataMapOfStringString_Substitute(self, theIndex, theKey1, theItem)

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

    def RemoveLast(self) -> "void":
        return _TColStd.TColStd_IndexedDataMapOfStringString_RemoveLast(self)

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

    def RemoveKey(self, theKey1: "TCollection_AsciiString") -> "void":
        return _TColStd.TColStd_IndexedDataMapOfStringString_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_IndexedDataMapOfStringString_FindKey(self, theIndex)

    def FindFromIndex(self, theIndex: "Standard_Integer const") -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_IndexedDataMapOfStringString_FindFromIndex(self, theIndex)

    def ChangeFromIndex(self, theIndex: "Standard_Integer const") -> "TCollection_AsciiString &":
        return _TColStd.TColStd_IndexedDataMapOfStringString_ChangeFromIndex(self, theIndex)

    def __call__(self, *args) -> "TCollection_AsciiString &":
        return _TColStd.TColStd_IndexedDataMapOfStringString___call__(self, *args)

    def FindIndex(self, theKey1: "TCollection_AsciiString") -> "Standard_Integer":
        return _TColStd.TColStd_IndexedDataMapOfStringString_FindIndex(self, theKey1)

    def ChangeFromKey(self, theKey1: "TCollection_AsciiString") -> "TCollection_AsciiString &":
        return _TColStd.TColStd_IndexedDataMapOfStringString_ChangeFromKey(self, theKey1)

    def Seek(self, theKey1: "TCollection_AsciiString") -> "TCollection_AsciiString const *":
        return _TColStd.TColStd_IndexedDataMapOfStringString_Seek(self, theKey1)

    def ChangeSeek(self, theKey1: "TCollection_AsciiString") -> "TCollection_AsciiString *":
        return _TColStd.TColStd_IndexedDataMapOfStringString_ChangeSeek(self, theKey1)

    def FindFromKey(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_IndexedDataMapOfStringString_FindFromKey(self, *args)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_IndexedDataMapOfStringString_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedDataMapOfStringString

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_IndexedDataMapOfStringString_Size(self)

# Register TColStd_IndexedDataMapOfStringString in _TColStd:
_TColStd.TColStd_IndexedDataMapOfStringString_swigregister(TColStd_IndexedDataMapOfStringString)

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

    def begin(self) -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::iterator":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_begin(self)

    def end(self) -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::iterator":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_end(self)

    def cbegin(self) -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::const_iterator":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_cbegin(self)

    def cend(self) -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::const_iterator":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedDataMapOfTransientTransient_swiginit(self, _TColStd.new_TColStd_IndexedDataMapOfTransientTransient(*args))

    def Exchange(self, theOther: "TColStd_IndexedDataMapOfTransientTransient") -> "void":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_IndexedDataMapOfTransientTransient") -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher > &":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Assign(self, theOther)

    def Set(self, theOther: "TColStd_IndexedDataMapOfTransientTransient") -> "NCollection_IndexedDataMap< opencascade::handle< Standard_Transient >,opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher > &":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Set(self, theOther)

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

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

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

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

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

    def RemoveLast(self) -> "void":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_RemoveLast(self)

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

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

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

    def FindFromIndex(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_FindFromIndex(self, theIndex)

    def ChangeFromIndex(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_ChangeFromIndex(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient___call__(self, *args)

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

    def ChangeFromKey(self, theKey1: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_ChangeFromKey(self, theKey1)

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

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

    def FindFromKey(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_FindFromKey(self, *args)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedDataMapOfTransientTransient

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Size(self)

# Register TColStd_IndexedDataMapOfTransientTransient in _TColStd:
_TColStd.TColStd_IndexedDataMapOfTransientTransient_swigregister(TColStd_IndexedDataMapOfTransientTransient)

class TColStd_IndexedMapOfInteger(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< int,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_IndexedMapOfInteger_cbegin(self)

    def cend(self) -> "NCollection_IndexedMap< int,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_IndexedMapOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedMapOfInteger_swiginit(self, _TColStd.new_TColStd_IndexedMapOfInteger(*args))

    def Exchange(self, theOther: "TColStd_IndexedMapOfInteger") -> "void":
        return _TColStd.TColStd_IndexedMapOfInteger_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_IndexedMapOfInteger") -> "NCollection_IndexedMap< Standard_Integer,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_IndexedMapOfInteger_Assign(self, theOther)

    def Set(self, theOther: "TColStd_IndexedMapOfInteger") -> "NCollection_IndexedMap< Standard_Integer,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_IndexedMapOfInteger_Set(self, theOther)

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

    def Add(self, theKey1: "int const &") -> "Standard_Integer":
        return _TColStd.TColStd_IndexedMapOfInteger_Add(self, theKey1)

    def Contains(self, theKey1: "int const &") -> "Standard_Boolean":
        return _TColStd.TColStd_IndexedMapOfInteger_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "int const &") -> "void":
        return _TColStd.TColStd_IndexedMapOfInteger_Substitute(self, theIndex, theKey1)

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

    def RemoveLast(self) -> "void":
        return _TColStd.TColStd_IndexedMapOfInteger_RemoveLast(self)

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

    def RemoveKey(self, theKey1: "int const &") -> "Standard_Boolean":
        return _TColStd.TColStd_IndexedMapOfInteger_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "int const &":
        return _TColStd.TColStd_IndexedMapOfInteger_FindKey(self, theIndex)

    def __call__(self, theIndex: "Standard_Integer const") -> "int const &":
        return _TColStd.TColStd_IndexedMapOfInteger___call__(self, theIndex)

    def FindIndex(self, theKey1: "int const &") -> "Standard_Integer":
        return _TColStd.TColStd_IndexedMapOfInteger_FindIndex(self, theKey1)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_IndexedMapOfInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedMapOfInteger

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_IndexedMapOfInteger_Size(self)

# Register TColStd_IndexedMapOfInteger in _TColStd:
_TColStd.TColStd_IndexedMapOfInteger_swigregister(TColStd_IndexedMapOfInteger)

class TColStd_IndexedMapOfReal(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< double,TColStd_MapRealHasher >::const_iterator":
        return _TColStd.TColStd_IndexedMapOfReal_cbegin(self)

    def cend(self) -> "NCollection_IndexedMap< double,TColStd_MapRealHasher >::const_iterator":
        return _TColStd.TColStd_IndexedMapOfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedMapOfReal_swiginit(self, _TColStd.new_TColStd_IndexedMapOfReal(*args))

    def Exchange(self, theOther: "TColStd_IndexedMapOfReal") -> "void":
        return _TColStd.TColStd_IndexedMapOfReal_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_IndexedMapOfReal") -> "NCollection_IndexedMap< Standard_Real,TColStd_MapRealHasher > &":
        return _TColStd.TColStd_IndexedMapOfReal_Assign(self, theOther)

    def Set(self, theOther: "TColStd_IndexedMapOfReal") -> "NCollection_IndexedMap< Standard_Real,TColStd_MapRealHasher > &":
        return _TColStd.TColStd_IndexedMapOfReal_Set(self, theOther)

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

    def Add(self, theKey1: "double const &") -> "Standard_Integer":
        return _TColStd.TColStd_IndexedMapOfReal_Add(self, theKey1)

    def Contains(self, theKey1: "double const &") -> "Standard_Boolean":
        return _TColStd.TColStd_IndexedMapOfReal_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "double const &") -> "void":
        return _TColStd.TColStd_IndexedMapOfReal_Substitute(self, theIndex, theKey1)

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

    def RemoveLast(self) -> "void":
        return _TColStd.TColStd_IndexedMapOfReal_RemoveLast(self)

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

    def RemoveKey(self, theKey1: "double const &") -> "Standard_Boolean":
        return _TColStd.TColStd_IndexedMapOfReal_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "double const &":
        return _TColStd.TColStd_IndexedMapOfReal_FindKey(self, theIndex)

    def __call__(self, theIndex: "Standard_Integer const") -> "double const &":
        return _TColStd.TColStd_IndexedMapOfReal___call__(self, theIndex)

    def FindIndex(self, theKey1: "double const &") -> "Standard_Integer":
        return _TColStd.TColStd_IndexedMapOfReal_FindIndex(self, theKey1)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_IndexedMapOfReal_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedMapOfReal

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_IndexedMapOfReal_Size(self)

# Register TColStd_IndexedMapOfReal in _TColStd:
_TColStd.TColStd_IndexedMapOfReal_swigregister(TColStd_IndexedMapOfReal)

class TColStd_IndexedMapOfTransient(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< Standard_Transient >,TColStd_MapTransientHasher >::const_iterator":
        return _TColStd.TColStd_IndexedMapOfTransient_cbegin(self)

    def cend(self) -> "NCollection_IndexedMap< opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::const_iterator":
        return _TColStd.TColStd_IndexedMapOfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedMapOfTransient_swiginit(self, _TColStd.new_TColStd_IndexedMapOfTransient(*args))

    def Exchange(self, theOther: "TColStd_IndexedMapOfTransient") -> "void":
        return _TColStd.TColStd_IndexedMapOfTransient_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_IndexedMapOfTransient") -> "NCollection_IndexedMap< opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher > &":
        return _TColStd.TColStd_IndexedMapOfTransient_Assign(self, theOther)

    def Set(self, theOther: "TColStd_IndexedMapOfTransient") -> "NCollection_IndexedMap< opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher > &":
        return _TColStd.TColStd_IndexedMapOfTransient_Set(self, theOther)

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

    def Add(self, theKey1: "opencascade::handle< Standard_Transient > const &") -> "Standard_Integer":
        return _TColStd.TColStd_IndexedMapOfTransient_Add(self, theKey1)

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

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "opencascade::handle< Standard_Transient > const &") -> "void":
        return _TColStd.TColStd_IndexedMapOfTransient_Substitute(self, theIndex, theKey1)

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

    def RemoveLast(self) -> "void":
        return _TColStd.TColStd_IndexedMapOfTransient_RemoveLast(self)

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

    def RemoveKey(self, theKey1: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
        return _TColStd.TColStd_IndexedMapOfTransient_RemoveKey(self, theKey1)

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

    def __call__(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_IndexedMapOfTransient___call__(self, theIndex)

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

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_IndexedMapOfTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedMapOfTransient

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_IndexedMapOfTransient_Size(self)

# Register TColStd_IndexedMapOfTransient in _TColStd:
_TColStd.TColStd_IndexedMapOfTransient_swigregister(TColStd_IndexedMapOfTransient)

class TColStd_ListIteratorOfListOfAsciiString(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):
        _TColStd.TColStd_ListIteratorOfListOfAsciiString_swiginit(self, _TColStd.new_TColStd_ListIteratorOfListOfAsciiString(*args))

    def More(self) -> "Standard_Boolean":
        return _TColStd.TColStd_ListIteratorOfListOfAsciiString_More(self)

    def Next(self) -> "void":
        return _TColStd.TColStd_ListIteratorOfListOfAsciiString_Next(self)

    def Value(self) -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_ListIteratorOfListOfAsciiString_Value(self)

    def ChangeValue(self) -> "TCollection_AsciiString &":
        return _TColStd.TColStd_ListIteratorOfListOfAsciiString_ChangeValue(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListIteratorOfListOfAsciiString

# Register TColStd_ListIteratorOfListOfAsciiString in _TColStd:
_TColStd.TColStd_ListIteratorOfListOfAsciiString_swigregister(TColStd_ListIteratorOfListOfAsciiString)

class TColStd_ListIteratorOfListOfInteger(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):
        _TColStd.TColStd_ListIteratorOfListOfInteger_swiginit(self, _TColStd.new_TColStd_ListIteratorOfListOfInteger(*args))

    def More(self) -> "Standard_Boolean":
        return _TColStd.TColStd_ListIteratorOfListOfInteger_More(self)

    def Next(self) -> "void":
        return _TColStd.TColStd_ListIteratorOfListOfInteger_Next(self)

    def Value(self) -> "int const &":
        return _TColStd.TColStd_ListIteratorOfListOfInteger_Value(self)

    def ChangeValue(self) -> "int &":
        return _TColStd.TColStd_ListIteratorOfListOfInteger_ChangeValue(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListIteratorOfListOfInteger

# Register TColStd_ListIteratorOfListOfInteger in _TColStd:
_TColStd.TColStd_ListIteratorOfListOfInteger_swigregister(TColStd_ListIteratorOfListOfInteger)

class TColStd_ListIteratorOfListOfReal(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):
        _TColStd.TColStd_ListIteratorOfListOfReal_swiginit(self, _TColStd.new_TColStd_ListIteratorOfListOfReal(*args))

    def More(self) -> "Standard_Boolean":
        return _TColStd.TColStd_ListIteratorOfListOfReal_More(self)

    def Next(self) -> "void":
        return _TColStd.TColStd_ListIteratorOfListOfReal_Next(self)

    def Value(self) -> "double const &":
        return _TColStd.TColStd_ListIteratorOfListOfReal_Value(self)

    def ChangeValue(self) -> "double &":
        return _TColStd.TColStd_ListIteratorOfListOfReal_ChangeValue(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListIteratorOfListOfReal

# Register TColStd_ListIteratorOfListOfReal in _TColStd:
_TColStd.TColStd_ListIteratorOfListOfReal_swigregister(TColStd_ListIteratorOfListOfReal)

class TColStd_ListIteratorOfListOfTransient(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):
        _TColStd.TColStd_ListIteratorOfListOfTransient_swiginit(self, _TColStd.new_TColStd_ListIteratorOfListOfTransient(*args))

    def More(self) -> "Standard_Boolean":
        return _TColStd.TColStd_ListIteratorOfListOfTransient_More(self)

    def Next(self) -> "void":
        return _TColStd.TColStd_ListIteratorOfListOfTransient_Next(self)

    def Value(self) -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_ListIteratorOfListOfTransient_Value(self)

    def ChangeValue(self) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_ListIteratorOfListOfTransient_ChangeValue(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListIteratorOfListOfTransient

# Register TColStd_ListIteratorOfListOfTransient in _TColStd:
_TColStd.TColStd_ListIteratorOfListOfTransient_swigregister(TColStd_ListIteratorOfListOfTransient)

class TColStd_ListOfAsciiString(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< TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_ListOfAsciiString_begin(self)

    def end(self) -> "NCollection_List< TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_ListOfAsciiString_end(self)

    def cbegin(self) -> "NCollection_List< TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_ListOfAsciiString_cbegin(self)

    def cend(self) -> "NCollection_List< TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_ListOfAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_ListOfAsciiString_swiginit(self, _TColStd.new_TColStd_ListOfAsciiString(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_ListOfAsciiString_Size(self)

    def Assign(self, theOther: "TColStd_ListOfAsciiString") -> "NCollection_List< TCollection_AsciiString > &":
        return _TColStd.TColStd_ListOfAsciiString_Assign(self, theOther)

    def Set(self, theOther: "TColStd_ListOfAsciiString") -> "NCollection_List< TCollection_AsciiString > &":
        return _TColStd.TColStd_ListOfAsciiString_Set(self, theOther)

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

    def First(self) -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_ListOfAsciiString_First(self)

    def Last(self) -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_ListOfAsciiString_Last(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_ListOfAsciiString_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_ListOfAsciiString_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _TColStd.TColStd_ListOfAsciiString_RemoveFirst(self)

    def Remove(self, theIter: "TColStd_ListIteratorOfListOfAsciiString") -> "void":
        return _TColStd.TColStd_ListOfAsciiString_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_ListOfAsciiString_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_ListOfAsciiString_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_ListOfAsciiString_Reverse(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListOfAsciiString

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


# Register TColStd_ListOfAsciiString in _TColStd:
_TColStd.TColStd_ListOfAsciiString_swigregister(TColStd_ListOfAsciiString)

class TColStd_ListOfInteger(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< int >::iterator":
        return _TColStd.TColStd_ListOfInteger_begin(self)

    def end(self) -> "NCollection_List< int >::iterator":
        return _TColStd.TColStd_ListOfInteger_end(self)

    def cbegin(self) -> "NCollection_List< int >::const_iterator":
        return _TColStd.TColStd_ListOfInteger_cbegin(self)

    def cend(self) -> "NCollection_List< int >::const_iterator":
        return _TColStd.TColStd_ListOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_ListOfInteger_swiginit(self, _TColStd.new_TColStd_ListOfInteger(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_ListOfInteger_Size(self)

    def Assign(self, theOther: "TColStd_ListOfInteger") -> "NCollection_List< Standard_Integer > &":
        return _TColStd.TColStd_ListOfInteger_Assign(self, theOther)

    def Set(self, theOther: "TColStd_ListOfInteger") -> "NCollection_List< Standard_Integer > &":
        return _TColStd.TColStd_ListOfInteger_Set(self, theOther)

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

    def First(self) -> "int const &":
        return _TColStd.TColStd_ListOfInteger_First(self)

    def Last(self) -> "int const &":
        return _TColStd.TColStd_ListOfInteger_Last(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_ListOfInteger_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_ListOfInteger_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _TColStd.TColStd_ListOfInteger_RemoveFirst(self)

    def Remove(self, theIter: "TColStd_ListIteratorOfListOfInteger") -> "void":
        return _TColStd.TColStd_ListOfInteger_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_ListOfInteger_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_ListOfInteger_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_ListOfInteger_Reverse(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListOfInteger

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


# Register TColStd_ListOfInteger in _TColStd:
_TColStd.TColStd_ListOfInteger_swigregister(TColStd_ListOfInteger)

class TColStd_ListOfReal(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< double >::iterator":
        return _TColStd.TColStd_ListOfReal_begin(self)

    def end(self) -> "NCollection_List< double >::iterator":
        return _TColStd.TColStd_ListOfReal_end(self)

    def cbegin(self) -> "NCollection_List< double >::const_iterator":
        return _TColStd.TColStd_ListOfReal_cbegin(self)

    def cend(self) -> "NCollection_List< double >::const_iterator":
        return _TColStd.TColStd_ListOfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_ListOfReal_swiginit(self, _TColStd.new_TColStd_ListOfReal(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_ListOfReal_Size(self)

    def Assign(self, theOther: "TColStd_ListOfReal") -> "NCollection_List< Standard_Real > &":
        return _TColStd.TColStd_ListOfReal_Assign(self, theOther)

    def Set(self, theOther: "TColStd_ListOfReal") -> "NCollection_List< Standard_Real > &":
        return _TColStd.TColStd_ListOfReal_Set(self, theOther)

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

    def First(self) -> "double const &":
        return _TColStd.TColStd_ListOfReal_First(self)

    def Last(self) -> "double const &":
        return _TColStd.TColStd_ListOfReal_Last(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_ListOfReal_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_ListOfReal_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _TColStd.TColStd_ListOfReal_RemoveFirst(self)

    def Remove(self, theIter: "TColStd_ListIteratorOfListOfReal") -> "void":
        return _TColStd.TColStd_ListOfReal_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_ListOfReal_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_ListOfReal_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_ListOfReal_Reverse(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListOfReal

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


# Register TColStd_ListOfReal in _TColStd:
_TColStd.TColStd_ListOfReal_swigregister(TColStd_ListOfReal)

class TColStd_ListOfTransient(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< Standard_Transient > >::iterator":
        return _TColStd.TColStd_ListOfTransient_begin(self)

    def end(self) -> "NCollection_List< opencascade::handle< Standard_Transient > >::iterator":
        return _TColStd.TColStd_ListOfTransient_end(self)

    def cbegin(self) -> "NCollection_List< opencascade::handle< Standard_Transient > >::const_iterator":
        return _TColStd.TColStd_ListOfTransient_cbegin(self)

    def cend(self) -> "NCollection_List< opencascade::handle< Standard_Transient > >::const_iterator":
        return _TColStd.TColStd_ListOfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_ListOfTransient_swiginit(self, _TColStd.new_TColStd_ListOfTransient(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_ListOfTransient_Size(self)

    def Assign(self, theOther: "TColStd_ListOfTransient") -> "NCollection_List< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_ListOfTransient_Assign(self, theOther)

    def Set(self, theOther: "TColStd_ListOfTransient") -> "NCollection_List< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_ListOfTransient_Set(self, theOther)

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

    def First(self) -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_ListOfTransient_First(self)

    def Last(self) -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_ListOfTransient_Last(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_ListOfTransient_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_ListOfTransient_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _TColStd.TColStd_ListOfTransient_RemoveFirst(self)

    def Remove(self, theIter: "TColStd_ListIteratorOfListOfTransient") -> "void":
        return _TColStd.TColStd_ListOfTransient_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_ListOfTransient_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_ListOfTransient_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_ListOfTransient_Reverse(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListOfTransient

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


# Register TColStd_ListOfTransient in _TColStd:
_TColStd.TColStd_ListOfTransient_swigregister(TColStd_ListOfTransient)

class TColStd_MapIntegerHasher(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(theKey: "int const &", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
        return _TColStd.TColStd_MapIntegerHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1: "int const &", theKey2: "int const &") -> "Standard_Boolean":
        return _TColStd.TColStd_MapIntegerHasher_IsEqual(theKey1, theKey2)

    def __init__(self):
        _TColStd.TColStd_MapIntegerHasher_swiginit(self, _TColStd.new_TColStd_MapIntegerHasher())
    __swig_destroy__ = _TColStd.delete_TColStd_MapIntegerHasher

# Register TColStd_MapIntegerHasher in _TColStd:
_TColStd.TColStd_MapIntegerHasher_swigregister(TColStd_MapIntegerHasher)

def TColStd_MapIntegerHasher_HashCode(theKey: "int const &", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
    return _TColStd.TColStd_MapIntegerHasher_HashCode(theKey, theUpperBound)

def TColStd_MapIntegerHasher_IsEqual(theKey1: "int const &", theKey2: "int const &") -> "Standard_Boolean":
    return _TColStd.TColStd_MapIntegerHasher_IsEqual(theKey1, theKey2)

class TColStd_MapOfAsciiString(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< TCollection_AsciiString,TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_MapOfAsciiString_cbegin(self)

    def cend(self) -> "NCollection_Map< TCollection_AsciiString,TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_MapOfAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_MapOfAsciiString_swiginit(self, _TColStd.new_TColStd_MapOfAsciiString(*args))

    def Exchange(self, theOther: "TColStd_MapOfAsciiString") -> "void":
        return _TColStd.TColStd_MapOfAsciiString_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_MapOfAsciiString") -> "NCollection_Map< TCollection_AsciiString,TCollection_AsciiString > &":
        return _TColStd.TColStd_MapOfAsciiString_Assign(self, theOther)

    def Set(self, theOther: "TColStd_MapOfAsciiString") -> "NCollection_Map< TCollection_AsciiString,TCollection_AsciiString > &":
        return _TColStd.TColStd_MapOfAsciiString_Set(self, theOther)

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

    def Add(self, K: "TCollection_AsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfAsciiString_Add(self, K)

    def Added(self, K: "TCollection_AsciiString") -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_MapOfAsciiString_Added(self, K)

    def Remove(self, K: "TCollection_AsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfAsciiString_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_MapOfAsciiString_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_MapOfAsciiString

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_MapOfAsciiString_Size(self)

    def IsEqual(self, theOther: "TColStd_MapOfAsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfAsciiString_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfAsciiString_Contains(self, *args)

    def Union(self, theLeft: "TColStd_MapOfAsciiString", theRight: "TColStd_MapOfAsciiString") -> "void":
        return _TColStd.TColStd_MapOfAsciiString_Union(self, theLeft, theRight)

    def Unite(self, theOther: "TColStd_MapOfAsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfAsciiString_Unite(self, theOther)

    def HasIntersection(self, theMap: "TColStd_MapOfAsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfAsciiString_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "TColStd_MapOfAsciiString", theRight: "TColStd_MapOfAsciiString") -> "void":
        return _TColStd.TColStd_MapOfAsciiString_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "TColStd_MapOfAsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfAsciiString_Intersect(self, theOther)

    def Subtraction(self, theLeft: "TColStd_MapOfAsciiString", theRight: "TColStd_MapOfAsciiString") -> "void":
        return _TColStd.TColStd_MapOfAsciiString_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "TColStd_MapOfAsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfAsciiString_Subtract(self, theOther)

    def Difference(self, theLeft: "TColStd_MapOfAsciiString", theRight: "TColStd_MapOfAsciiString") -> "void":
        return _TColStd.TColStd_MapOfAsciiString_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "TColStd_MapOfAsciiString") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfAsciiString_Differ(self, theOther)

# Register TColStd_MapOfAsciiString in _TColStd:
_TColStd.TColStd_MapOfAsciiString_swigregister(TColStd_MapOfAsciiString)

class TColStd_MapOfInteger(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< int,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_MapOfInteger_cbegin(self)

    def cend(self) -> "NCollection_Map< int,TColStd_MapIntegerHasher >::const_iterator":
        return _TColStd.TColStd_MapOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_MapOfInteger_swiginit(self, _TColStd.new_TColStd_MapOfInteger(*args))

    def Exchange(self, theOther: "TColStd_MapOfInteger") -> "void":
        return _TColStd.TColStd_MapOfInteger_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_MapOfInteger") -> "NCollection_Map< Standard_Integer,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_MapOfInteger_Assign(self, theOther)

    def Set(self, theOther: "TColStd_MapOfInteger") -> "NCollection_Map< Standard_Integer,TColStd_MapIntegerHasher > &":
        return _TColStd.TColStd_MapOfInteger_Set(self, theOther)

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

    def Add(self, K: "int const &") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfInteger_Add(self, K)

    def Added(self, K: "int const &") -> "int const &":
        return _TColStd.TColStd_MapOfInteger_Added(self, K)

    def Remove(self, K: "int const &") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfInteger_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_MapOfInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_MapOfInteger

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_MapOfInteger_Size(self)

    def IsEqual(self, theOther: "TColStd_MapOfInteger") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfInteger_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfInteger_Contains(self, *args)

    def Union(self, theLeft: "TColStd_MapOfInteger", theRight: "TColStd_MapOfInteger") -> "void":
        return _TColStd.TColStd_MapOfInteger_Union(self, theLeft, theRight)

    def Unite(self, theOther: "TColStd_MapOfInteger") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfInteger_Unite(self, theOther)

    def HasIntersection(self, theMap: "TColStd_MapOfInteger") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfInteger_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "TColStd_MapOfInteger", theRight: "TColStd_MapOfInteger") -> "void":
        return _TColStd.TColStd_MapOfInteger_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "TColStd_MapOfInteger") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfInteger_Intersect(self, theOther)

    def Subtraction(self, theLeft: "TColStd_MapOfInteger", theRight: "TColStd_MapOfInteger") -> "void":
        return _TColStd.TColStd_MapOfInteger_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "TColStd_MapOfInteger") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfInteger_Subtract(self, theOther)

    def Difference(self, theLeft: "TColStd_MapOfInteger", theRight: "TColStd_MapOfInteger") -> "void":
        return _TColStd.TColStd_MapOfInteger_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "TColStd_MapOfInteger") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfInteger_Differ(self, theOther)

# Register TColStd_MapOfInteger in _TColStd:
_TColStd.TColStd_MapOfInteger_swigregister(TColStd_MapOfInteger)

class TColStd_MapOfReal(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< double,TColStd_MapRealHasher >::const_iterator":
        return _TColStd.TColStd_MapOfReal_cbegin(self)

    def cend(self) -> "NCollection_Map< double,TColStd_MapRealHasher >::const_iterator":
        return _TColStd.TColStd_MapOfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_MapOfReal_swiginit(self, _TColStd.new_TColStd_MapOfReal(*args))

    def Exchange(self, theOther: "TColStd_MapOfReal") -> "void":
        return _TColStd.TColStd_MapOfReal_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_MapOfReal") -> "NCollection_Map< Standard_Real,TColStd_MapRealHasher > &":
        return _TColStd.TColStd_MapOfReal_Assign(self, theOther)

    def Set(self, theOther: "TColStd_MapOfReal") -> "NCollection_Map< Standard_Real,TColStd_MapRealHasher > &":
        return _TColStd.TColStd_MapOfReal_Set(self, theOther)

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

    def Add(self, K: "double const &") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfReal_Add(self, K)

    def Added(self, K: "double const &") -> "double const &":
        return _TColStd.TColStd_MapOfReal_Added(self, K)

    def Remove(self, K: "double const &") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfReal_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_MapOfReal_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_MapOfReal

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_MapOfReal_Size(self)

    def IsEqual(self, theOther: "TColStd_MapOfReal") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfReal_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfReal_Contains(self, *args)

    def Union(self, theLeft: "TColStd_MapOfReal", theRight: "TColStd_MapOfReal") -> "void":
        return _TColStd.TColStd_MapOfReal_Union(self, theLeft, theRight)

    def Unite(self, theOther: "TColStd_MapOfReal") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfReal_Unite(self, theOther)

    def HasIntersection(self, theMap: "TColStd_MapOfReal") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfReal_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "TColStd_MapOfReal", theRight: "TColStd_MapOfReal") -> "void":
        return _TColStd.TColStd_MapOfReal_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "TColStd_MapOfReal") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfReal_Intersect(self, theOther)

    def Subtraction(self, theLeft: "TColStd_MapOfReal", theRight: "TColStd_MapOfReal") -> "void":
        return _TColStd.TColStd_MapOfReal_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "TColStd_MapOfReal") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfReal_Subtract(self, theOther)

    def Difference(self, theLeft: "TColStd_MapOfReal", theRight: "TColStd_MapOfReal") -> "void":
        return _TColStd.TColStd_MapOfReal_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "TColStd_MapOfReal") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfReal_Differ(self, theOther)

# Register TColStd_MapOfReal in _TColStd:
_TColStd.TColStd_MapOfReal_swigregister(TColStd_MapOfReal)

class TColStd_MapOfTransient(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< Standard_Transient >,TColStd_MapTransientHasher >::const_iterator":
        return _TColStd.TColStd_MapOfTransient_cbegin(self)

    def cend(self) -> "NCollection_Map< opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher >::const_iterator":
        return _TColStd.TColStd_MapOfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_MapOfTransient_swiginit(self, _TColStd.new_TColStd_MapOfTransient(*args))

    def Exchange(self, theOther: "TColStd_MapOfTransient") -> "void":
        return _TColStd.TColStd_MapOfTransient_Exchange(self, theOther)

    def Assign(self, theOther: "TColStd_MapOfTransient") -> "NCollection_Map< opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher > &":
        return _TColStd.TColStd_MapOfTransient_Assign(self, theOther)

    def Set(self, theOther: "TColStd_MapOfTransient") -> "NCollection_Map< opencascade::handle< Standard_Transient >,TColStd_MapTransientHasher > &":
        return _TColStd.TColStd_MapOfTransient_Set(self, theOther)

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

    def Add(self, K: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfTransient_Add(self, K)

    def Added(self, K: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_MapOfTransient_Added(self, K)

    def Remove(self, K: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfTransient_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _TColStd.TColStd_MapOfTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_MapOfTransient

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_MapOfTransient_Size(self)

    def IsEqual(self, theOther: "TColStd_MapOfTransient") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfTransient_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfTransient_Contains(self, *args)

    def Union(self, theLeft: "TColStd_MapOfTransient", theRight: "TColStd_MapOfTransient") -> "void":
        return _TColStd.TColStd_MapOfTransient_Union(self, theLeft, theRight)

    def Unite(self, theOther: "TColStd_MapOfTransient") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfTransient_Unite(self, theOther)

    def HasIntersection(self, theMap: "TColStd_MapOfTransient") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfTransient_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "TColStd_MapOfTransient", theRight: "TColStd_MapOfTransient") -> "void":
        return _TColStd.TColStd_MapOfTransient_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "TColStd_MapOfTransient") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfTransient_Intersect(self, theOther)

    def Subtraction(self, theLeft: "TColStd_MapOfTransient", theRight: "TColStd_MapOfTransient") -> "void":
        return _TColStd.TColStd_MapOfTransient_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "TColStd_MapOfTransient") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfTransient_Subtract(self, theOther)

    def Difference(self, theLeft: "TColStd_MapOfTransient", theRight: "TColStd_MapOfTransient") -> "void":
        return _TColStd.TColStd_MapOfTransient_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "TColStd_MapOfTransient") -> "Standard_Boolean":
        return _TColStd.TColStd_MapOfTransient_Differ(self, theOther)

# Register TColStd_MapOfTransient in _TColStd:
_TColStd.TColStd_MapOfTransient_swigregister(TColStd_MapOfTransient)

class TColStd_MapRealHasher(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(theKey: "double const &", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
        return _TColStd.TColStd_MapRealHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1: "double const &", theKey2: "double const &") -> "Standard_Boolean":
        return _TColStd.TColStd_MapRealHasher_IsEqual(theKey1, theKey2)

    def __init__(self):
        _TColStd.TColStd_MapRealHasher_swiginit(self, _TColStd.new_TColStd_MapRealHasher())
    __swig_destroy__ = _TColStd.delete_TColStd_MapRealHasher

# Register TColStd_MapRealHasher in _TColStd:
_TColStd.TColStd_MapRealHasher_swigregister(TColStd_MapRealHasher)

def TColStd_MapRealHasher_HashCode(theKey: "double const &", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
    return _TColStd.TColStd_MapRealHasher_HashCode(theKey, theUpperBound)

def TColStd_MapRealHasher_IsEqual(theKey1: "double const &", theKey2: "double const &") -> "Standard_Boolean":
    return _TColStd.TColStd_MapRealHasher_IsEqual(theKey1, theKey2)

class TColStd_MapTransientHasher(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(theKey: "opencascade::handle< Standard_Transient > const &", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
        return _TColStd.TColStd_MapTransientHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1: "opencascade::handle< Standard_Transient > const &", theKey2: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
        return _TColStd.TColStd_MapTransientHasher_IsEqual(theKey1, theKey2)

    def __init__(self):
        _TColStd.TColStd_MapTransientHasher_swiginit(self, _TColStd.new_TColStd_MapTransientHasher())
    __swig_destroy__ = _TColStd.delete_TColStd_MapTransientHasher

# Register TColStd_MapTransientHasher in _TColStd:
_TColStd.TColStd_MapTransientHasher_swigregister(TColStd_MapTransientHasher)

def TColStd_MapTransientHasher_HashCode(theKey: "opencascade::handle< Standard_Transient > const &", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
    return _TColStd.TColStd_MapTransientHasher_HashCode(theKey, theUpperBound)

def TColStd_MapTransientHasher_IsEqual(theKey1: "opencascade::handle< Standard_Transient > const &", theKey2: "opencascade::handle< Standard_Transient > const &") -> "Standard_Boolean":
    return _TColStd.TColStd_MapTransientHasher_IsEqual(theKey1, theKey2)

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

    def begin(self) -> "NCollection_Sequence< void * >::iterator":
        return _TColStd.TColStd_SequenceOfAddress_begin(self)

    def end(self) -> "NCollection_Sequence< void * >::iterator":
        return _TColStd.TColStd_SequenceOfAddress_end(self)

    def cbegin(self) -> "NCollection_Sequence< void * >::const_iterator":
        return _TColStd.TColStd_SequenceOfAddress_cbegin(self)

    def cend(self) -> "NCollection_Sequence< void * >::const_iterator":
        return _TColStd.TColStd_SequenceOfAddress_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfAddress_swiginit(self, _TColStd.new_TColStd_SequenceOfAddress(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfAddress_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfAddress_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfAddress_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfAddress_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_SequenceOfAddress_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_SequenceOfAddress_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColStd_SequenceOfAddress") -> "NCollection_Sequence< void * > &":
        return _TColStd.TColStd_SequenceOfAddress_Assign(self, theOther)

    def Set(self, theOther: "TColStd_SequenceOfAddress") -> "NCollection_Sequence< void * > &":
        return _TColStd.TColStd_SequenceOfAddress_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAddress_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAddress_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAddress_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAddress_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAddress_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColStd_SequenceOfAddress") -> "void":
        return _TColStd.TColStd_SequenceOfAddress_Split(self, theIndex, theSeq)

    def First(self) -> "void *const &":
        return _TColStd.TColStd_SequenceOfAddress_First(self)

    def ChangeFirst(self) -> "void *&":
        return _TColStd.TColStd_SequenceOfAddress_ChangeFirst(self)

    def Last(self) -> "void *const &":
        return _TColStd.TColStd_SequenceOfAddress_Last(self)

    def ChangeLast(self) -> "void *&":
        return _TColStd.TColStd_SequenceOfAddress_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "void *const &":
        return _TColStd.TColStd_SequenceOfAddress_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "void *&":
        return _TColStd.TColStd_SequenceOfAddress_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "void *&":
        return _TColStd.TColStd_SequenceOfAddress___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "void *const &") -> "void":
        return _TColStd.TColStd_SequenceOfAddress_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfAddress

# Register TColStd_SequenceOfAddress in _TColStd:
_TColStd.TColStd_SequenceOfAddress_swigregister(TColStd_SequenceOfAddress)

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

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

    def begin(self) -> "NCollection_Sequence< TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_SequenceOfAsciiString_begin(self)

    def end(self) -> "NCollection_Sequence< TCollection_AsciiString >::iterator":
        return _TColStd.TColStd_SequenceOfAsciiString_end(self)

    def cbegin(self) -> "NCollection_Sequence< TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_SequenceOfAsciiString_cbegin(self)

    def cend(self) -> "NCollection_Sequence< TCollection_AsciiString >::const_iterator":
        return _TColStd.TColStd_SequenceOfAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfAsciiString_swiginit(self, _TColStd.new_TColStd_SequenceOfAsciiString(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfAsciiString_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfAsciiString_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfAsciiString_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfAsciiString_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_SequenceOfAsciiString_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_SequenceOfAsciiString_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColStd_SequenceOfAsciiString") -> "NCollection_Sequence< TCollection_AsciiString > &":
        return _TColStd.TColStd_SequenceOfAsciiString_Assign(self, theOther)

    def Set(self, theOther: "TColStd_SequenceOfAsciiString") -> "NCollection_Sequence< TCollection_AsciiString > &":
        return _TColStd.TColStd_SequenceOfAsciiString_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAsciiString_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAsciiString_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAsciiString_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAsciiString_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfAsciiString_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColStd_SequenceOfAsciiString") -> "void":
        return _TColStd.TColStd_SequenceOfAsciiString_Split(self, theIndex, theSeq)

    def First(self) -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_SequenceOfAsciiString_First(self)

    def ChangeFirst(self) -> "TCollection_AsciiString &":
        return _TColStd.TColStd_SequenceOfAsciiString_ChangeFirst(self)

    def Last(self) -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_SequenceOfAsciiString_Last(self)

    def ChangeLast(self) -> "TCollection_AsciiString &":
        return _TColStd.TColStd_SequenceOfAsciiString_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "TCollection_AsciiString const &":
        return _TColStd.TColStd_SequenceOfAsciiString_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "TCollection_AsciiString &":
        return _TColStd.TColStd_SequenceOfAsciiString_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "TCollection_AsciiString &":
        return _TColStd.TColStd_SequenceOfAsciiString___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "TCollection_AsciiString") -> "void":
        return _TColStd.TColStd_SequenceOfAsciiString_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfAsciiString

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


# Register TColStd_SequenceOfAsciiString in _TColStd:
_TColStd.TColStd_SequenceOfAsciiString_swigregister(TColStd_SequenceOfAsciiString)

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

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

    def begin(self) -> "NCollection_Sequence< bool >::iterator":
        return _TColStd.TColStd_SequenceOfBoolean_begin(self)

    def end(self) -> "NCollection_Sequence< bool >::iterator":
        return _TColStd.TColStd_SequenceOfBoolean_end(self)

    def cbegin(self) -> "NCollection_Sequence< bool >::const_iterator":
        return _TColStd.TColStd_SequenceOfBoolean_cbegin(self)

    def cend(self) -> "NCollection_Sequence< bool >::const_iterator":
        return _TColStd.TColStd_SequenceOfBoolean_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfBoolean_swiginit(self, _TColStd.new_TColStd_SequenceOfBoolean(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfBoolean_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfBoolean_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfBoolean_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfBoolean_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_SequenceOfBoolean_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_SequenceOfBoolean_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColStd_SequenceOfBoolean") -> "NCollection_Sequence< Standard_Boolean > &":
        return _TColStd.TColStd_SequenceOfBoolean_Assign(self, theOther)

    def Set(self, theOther: "TColStd_SequenceOfBoolean") -> "NCollection_Sequence< Standard_Boolean > &":
        return _TColStd.TColStd_SequenceOfBoolean_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfBoolean_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfBoolean_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfBoolean_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfBoolean_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfBoolean_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColStd_SequenceOfBoolean") -> "void":
        return _TColStd.TColStd_SequenceOfBoolean_Split(self, theIndex, theSeq)

    def First(self) -> "bool const &":
        return _TColStd.TColStd_SequenceOfBoolean_First(self)

    def ChangeFirst(self) -> "bool &":
        return _TColStd.TColStd_SequenceOfBoolean_ChangeFirst(self)

    def Last(self) -> "bool const &":
        return _TColStd.TColStd_SequenceOfBoolean_Last(self)

    def ChangeLast(self) -> "bool &":
        return _TColStd.TColStd_SequenceOfBoolean_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "bool const &":
        return _TColStd.TColStd_SequenceOfBoolean_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "bool &":
        return _TColStd.TColStd_SequenceOfBoolean_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "bool &":
        return _TColStd.TColStd_SequenceOfBoolean___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "bool const &") -> "void":
        return _TColStd.TColStd_SequenceOfBoolean_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfBoolean

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


# Register TColStd_SequenceOfBoolean in _TColStd:
_TColStd.TColStd_SequenceOfBoolean_swigregister(TColStd_SequenceOfBoolean)

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

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

    def begin(self) -> "NCollection_Sequence< TCollection_ExtendedString >::iterator":
        return _TColStd.TColStd_SequenceOfExtendedString_begin(self)

    def end(self) -> "NCollection_Sequence< TCollection_ExtendedString >::iterator":
        return _TColStd.TColStd_SequenceOfExtendedString_end(self)

    def cbegin(self) -> "NCollection_Sequence< TCollection_ExtendedString >::const_iterator":
        return _TColStd.TColStd_SequenceOfExtendedString_cbegin(self)

    def cend(self) -> "NCollection_Sequence< TCollection_ExtendedString >::const_iterator":
        return _TColStd.TColStd_SequenceOfExtendedString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfExtendedString_swiginit(self, _TColStd.new_TColStd_SequenceOfExtendedString(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfExtendedString_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfExtendedString_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfExtendedString_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfExtendedString_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_SequenceOfExtendedString_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_SequenceOfExtendedString_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColStd_SequenceOfExtendedString") -> "NCollection_Sequence< TCollection_ExtendedString > &":
        return _TColStd.TColStd_SequenceOfExtendedString_Assign(self, theOther)

    def Set(self, theOther: "TColStd_SequenceOfExtendedString") -> "NCollection_Sequence< TCollection_ExtendedString > &":
        return _TColStd.TColStd_SequenceOfExtendedString_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfExtendedString_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfExtendedString_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfExtendedString_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfExtendedString_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfExtendedString_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColStd_SequenceOfExtendedString") -> "void":
        return _TColStd.TColStd_SequenceOfExtendedString_Split(self, theIndex, theSeq)

    def First(self) -> "TCollection_ExtendedString const &":
        return _TColStd.TColStd_SequenceOfExtendedString_First(self)

    def ChangeFirst(self) -> "TCollection_ExtendedString &":
        return _TColStd.TColStd_SequenceOfExtendedString_ChangeFirst(self)

    def Last(self) -> "TCollection_ExtendedString const &":
        return _TColStd.TColStd_SequenceOfExtendedString_Last(self)

    def ChangeLast(self) -> "TCollection_ExtendedString &":
        return _TColStd.TColStd_SequenceOfExtendedString_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "TCollection_ExtendedString const &":
        return _TColStd.TColStd_SequenceOfExtendedString_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "TCollection_ExtendedString &":
        return _TColStd.TColStd_SequenceOfExtendedString_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "TCollection_ExtendedString &":
        return _TColStd.TColStd_SequenceOfExtendedString___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "TCollection_ExtendedString") -> "void":
        return _TColStd.TColStd_SequenceOfExtendedString_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfExtendedString

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


# Register TColStd_SequenceOfExtendedString in _TColStd:
_TColStd.TColStd_SequenceOfExtendedString_swigregister(TColStd_SequenceOfExtendedString)

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

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

    def begin(self) -> "NCollection_Sequence< opencascade::handle< TCollection_HAsciiString > >::iterator":
        return _TColStd.TColStd_SequenceOfHAsciiString_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< TCollection_HAsciiString > >::iterator":
        return _TColStd.TColStd_SequenceOfHAsciiString_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< TCollection_HAsciiString > >::const_iterator":
        return _TColStd.TColStd_SequenceOfHAsciiString_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< TCollection_HAsciiString > >::const_iterator":
        return _TColStd.TColStd_SequenceOfHAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfHAsciiString_swiginit(self, _TColStd.new_TColStd_SequenceOfHAsciiString(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfHAsciiString_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfHAsciiString_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfHAsciiString_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfHAsciiString_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_SequenceOfHAsciiString_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_SequenceOfHAsciiString_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColStd_SequenceOfHAsciiString") -> "NCollection_Sequence< opencascade::handle< TCollection_HAsciiString > > &":
        return _TColStd.TColStd_SequenceOfHAsciiString_Assign(self, theOther)

    def Set(self, theOther: "TColStd_SequenceOfHAsciiString") -> "NCollection_Sequence< opencascade::handle< TCollection_HAsciiString > > &":
        return _TColStd.TColStd_SequenceOfHAsciiString_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHAsciiString_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHAsciiString_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHAsciiString_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHAsciiString_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHAsciiString_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColStd_SequenceOfHAsciiString") -> "void":
        return _TColStd.TColStd_SequenceOfHAsciiString_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< TCollection_HAsciiString > const &":
        return _TColStd.TColStd_SequenceOfHAsciiString_First(self)

    def ChangeFirst(self) -> "opencascade::handle< TCollection_HAsciiString > &":
        return _TColStd.TColStd_SequenceOfHAsciiString_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< TCollection_HAsciiString > const &":
        return _TColStd.TColStd_SequenceOfHAsciiString_Last(self)

    def ChangeLast(self) -> "opencascade::handle< TCollection_HAsciiString > &":
        return _TColStd.TColStd_SequenceOfHAsciiString_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< TCollection_HAsciiString > const &":
        return _TColStd.TColStd_SequenceOfHAsciiString_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< TCollection_HAsciiString > &":
        return _TColStd.TColStd_SequenceOfHAsciiString_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< TCollection_HAsciiString > &":
        return _TColStd.TColStd_SequenceOfHAsciiString___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< TCollection_HAsciiString > const &") -> "void":
        return _TColStd.TColStd_SequenceOfHAsciiString_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfHAsciiString

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


# Register TColStd_SequenceOfHAsciiString in _TColStd:
_TColStd.TColStd_SequenceOfHAsciiString_swigregister(TColStd_SequenceOfHAsciiString)

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

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

    def begin(self) -> "NCollection_Sequence< opencascade::handle< TCollection_HExtendedString > >::iterator":
        return _TColStd.TColStd_SequenceOfHExtendedString_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< TCollection_HExtendedString > >::iterator":
        return _TColStd.TColStd_SequenceOfHExtendedString_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< TCollection_HExtendedString > >::const_iterator":
        return _TColStd.TColStd_SequenceOfHExtendedString_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< TCollection_HExtendedString > >::const_iterator":
        return _TColStd.TColStd_SequenceOfHExtendedString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfHExtendedString_swiginit(self, _TColStd.new_TColStd_SequenceOfHExtendedString(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfHExtendedString_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfHExtendedString_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfHExtendedString_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfHExtendedString_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_SequenceOfHExtendedString_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_SequenceOfHExtendedString_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColStd_SequenceOfHExtendedString") -> "NCollection_Sequence< opencascade::handle< TCollection_HExtendedString > > &":
        return _TColStd.TColStd_SequenceOfHExtendedString_Assign(self, theOther)

    def Set(self, theOther: "TColStd_SequenceOfHExtendedString") -> "NCollection_Sequence< opencascade::handle< TCollection_HExtendedString > > &":
        return _TColStd.TColStd_SequenceOfHExtendedString_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHExtendedString_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHExtendedString_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHExtendedString_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHExtendedString_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfHExtendedString_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColStd_SequenceOfHExtendedString") -> "void":
        return _TColStd.TColStd_SequenceOfHExtendedString_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< TCollection_HExtendedString > const &":
        return _TColStd.TColStd_SequenceOfHExtendedString_First(self)

    def ChangeFirst(self) -> "opencascade::handle< TCollection_HExtendedString > &":
        return _TColStd.TColStd_SequenceOfHExtendedString_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< TCollection_HExtendedString > const &":
        return _TColStd.TColStd_SequenceOfHExtendedString_Last(self)

    def ChangeLast(self) -> "opencascade::handle< TCollection_HExtendedString > &":
        return _TColStd.TColStd_SequenceOfHExtendedString_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< TCollection_HExtendedString > const &":
        return _TColStd.TColStd_SequenceOfHExtendedString_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< TCollection_HExtendedString > &":
        return _TColStd.TColStd_SequenceOfHExtendedString_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< TCollection_HExtendedString > &":
        return _TColStd.TColStd_SequenceOfHExtendedString___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< TCollection_HExtendedString > const &") -> "void":
        return _TColStd.TColStd_SequenceOfHExtendedString_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfHExtendedString

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


# Register TColStd_SequenceOfHExtendedString in _TColStd:
_TColStd.TColStd_SequenceOfHExtendedString_swigregister(TColStd_SequenceOfHExtendedString)

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

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

    def begin(self) -> "NCollection_Sequence< int >::iterator":
        return _TColStd.TColStd_SequenceOfInteger_begin(self)

    def end(self) -> "NCollection_Sequence< int >::iterator":
        return _TColStd.TColStd_SequenceOfInteger_end(self)

    def cbegin(self) -> "NCollection_Sequence< int >::const_iterator":
        return _TColStd.TColStd_SequenceOfInteger_cbegin(self)

    def cend(self) -> "NCollection_Sequence< int >::const_iterator":
        return _TColStd.TColStd_SequenceOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfInteger_swiginit(self, _TColStd.new_TColStd_SequenceOfInteger(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfInteger_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfInteger_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfInteger_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfInteger_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_SequenceOfInteger_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_SequenceOfInteger_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColStd_SequenceOfInteger") -> "NCollection_Sequence< Standard_Integer > &":
        return _TColStd.TColStd_SequenceOfInteger_Assign(self, theOther)

    def Set(self, theOther: "TColStd_SequenceOfInteger") -> "NCollection_Sequence< Standard_Integer > &":
        return _TColStd.TColStd_SequenceOfInteger_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfInteger_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfInteger_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfInteger_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfInteger_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfInteger_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColStd_SequenceOfInteger") -> "void":
        return _TColStd.TColStd_SequenceOfInteger_Split(self, theIndex, theSeq)

    def First(self) -> "int const &":
        return _TColStd.TColStd_SequenceOfInteger_First(self)

    def ChangeFirst(self) -> "int &":
        return _TColStd.TColStd_SequenceOfInteger_ChangeFirst(self)

    def Last(self) -> "int const &":
        return _TColStd.TColStd_SequenceOfInteger_Last(self)

    def ChangeLast(self) -> "int &":
        return _TColStd.TColStd_SequenceOfInteger_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "int const &":
        return _TColStd.TColStd_SequenceOfInteger_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "int &":
        return _TColStd.TColStd_SequenceOfInteger_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "int &":
        return _TColStd.TColStd_SequenceOfInteger___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "int const &") -> "void":
        return _TColStd.TColStd_SequenceOfInteger_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfInteger

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


# Register TColStd_SequenceOfInteger in _TColStd:
_TColStd.TColStd_SequenceOfInteger_swigregister(TColStd_SequenceOfInteger)

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

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

    def begin(self) -> "NCollection_Sequence< double >::iterator":
        return _TColStd.TColStd_SequenceOfReal_begin(self)

    def end(self) -> "NCollection_Sequence< double >::iterator":
        return _TColStd.TColStd_SequenceOfReal_end(self)

    def cbegin(self) -> "NCollection_Sequence< double >::const_iterator":
        return _TColStd.TColStd_SequenceOfReal_cbegin(self)

    def cend(self) -> "NCollection_Sequence< double >::const_iterator":
        return _TColStd.TColStd_SequenceOfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfReal_swiginit(self, _TColStd.new_TColStd_SequenceOfReal(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfReal_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfReal_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfReal_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfReal_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_SequenceOfReal_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_SequenceOfReal_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColStd_SequenceOfReal") -> "NCollection_Sequence< Standard_Real > &":
        return _TColStd.TColStd_SequenceOfReal_Assign(self, theOther)

    def Set(self, theOther: "TColStd_SequenceOfReal") -> "NCollection_Sequence< Standard_Real > &":
        return _TColStd.TColStd_SequenceOfReal_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfReal_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfReal_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfReal_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfReal_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfReal_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColStd_SequenceOfReal") -> "void":
        return _TColStd.TColStd_SequenceOfReal_Split(self, theIndex, theSeq)

    def First(self) -> "double const &":
        return _TColStd.TColStd_SequenceOfReal_First(self)

    def ChangeFirst(self) -> "double &":
        return _TColStd.TColStd_SequenceOfReal_ChangeFirst(self)

    def Last(self) -> "double const &":
        return _TColStd.TColStd_SequenceOfReal_Last(self)

    def ChangeLast(self) -> "double &":
        return _TColStd.TColStd_SequenceOfReal_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "double const &":
        return _TColStd.TColStd_SequenceOfReal_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "double &":
        return _TColStd.TColStd_SequenceOfReal_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "double &":
        return _TColStd.TColStd_SequenceOfReal___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "double const &") -> "void":
        return _TColStd.TColStd_SequenceOfReal_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfReal

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


# Register TColStd_SequenceOfReal in _TColStd:
_TColStd.TColStd_SequenceOfReal_swigregister(TColStd_SequenceOfReal)

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

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

    def begin(self) -> "NCollection_Sequence< opencascade::handle< Standard_Transient > >::iterator":
        return _TColStd.TColStd_SequenceOfTransient_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< Standard_Transient > >::iterator":
        return _TColStd.TColStd_SequenceOfTransient_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< Standard_Transient > >::const_iterator":
        return _TColStd.TColStd_SequenceOfTransient_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< Standard_Transient > >::const_iterator":
        return _TColStd.TColStd_SequenceOfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfTransient_swiginit(self, _TColStd.new_TColStd_SequenceOfTransient(*args))

    def Size(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfTransient_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfTransient_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfTransient_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColStd.TColStd_SequenceOfTransient_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColStd.TColStd_SequenceOfTransient_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColStd.TColStd_SequenceOfTransient_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColStd_SequenceOfTransient") -> "NCollection_Sequence< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_SequenceOfTransient_Assign(self, theOther)

    def Set(self, theOther: "TColStd_SequenceOfTransient") -> "NCollection_Sequence< opencascade::handle< Standard_Transient > > &":
        return _TColStd.TColStd_SequenceOfTransient_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfTransient_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfTransient_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfTransient_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfTransient_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColStd.TColStd_SequenceOfTransient_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColStd_SequenceOfTransient") -> "void":
        return _TColStd.TColStd_SequenceOfTransient_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_SequenceOfTransient_First(self)

    def ChangeFirst(self) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_SequenceOfTransient_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_SequenceOfTransient_Last(self)

    def ChangeLast(self) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_SequenceOfTransient_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > const &":
        return _TColStd.TColStd_SequenceOfTransient_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_SequenceOfTransient_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Standard_Transient > &":
        return _TColStd.TColStd_SequenceOfTransient___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< Standard_Transient > const &") -> "void":
        return _TColStd.TColStd_SequenceOfTransient_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfTransient

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


# Register TColStd_SequenceOfTransient in _TColStd:
_TColStd.TColStd_SequenceOfTransient_swigregister(TColStd_SequenceOfTransient)

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

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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        NbBuckets: int,optional
        	default value is 1

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        theOther: TColStd_PackedMapOfInteger

        Returns
        -------
        None

        """
        _TColStd.TColStd_HPackedMapOfInteger_swiginit(self, _TColStd.new_TColStd_HPackedMapOfInteger(*args))

    def ChangeMap(self, *args) -> "TColStd_PackedMapOfInteger &":
        r"""
        No available documentation.

        Returns
        -------
        TColStd_PackedMapOfInteger

        """
        return _TColStd.TColStd_HPackedMapOfInteger_ChangeMap(self, *args)

    def Map(self, *args) -> "TColStd_PackedMapOfInteger const &":
        r"""
        No available documentation.

        Returns
        -------
        TColStd_PackedMapOfInteger

        """
        return _TColStd.TColStd_HPackedMapOfInteger_Map(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _TColStd.delete_TColStd_HPackedMapOfInteger

# Register TColStd_HPackedMapOfInteger in _TColStd:
_TColStd.TColStd_HPackedMapOfInteger_swigregister(TColStd_HPackedMapOfInteger)

class TColStd_HArray1OfExtendedString(TColStd_Array1OfExtendedString, 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):
        _TColStd.TColStd_HArray1OfExtendedString_swiginit(self, _TColStd.new_TColStd_HArray1OfExtendedString(*args))

    def Array1(self) -> "TColStd_Array1OfExtendedString const &":
        return _TColStd.TColStd_HArray1OfExtendedString_Array1(self)

    def ChangeArray1(self) -> "TColStd_Array1OfExtendedString &":
        return _TColStd.TColStd_HArray1OfExtendedString_ChangeArray1(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfExtendedString

# Register TColStd_HArray1OfExtendedString in _TColStd:
_TColStd.TColStd_HArray1OfExtendedString_swigregister(TColStd_HArray1OfExtendedString)

class TColStd_HArray1OfCharacter(TColStd_Array1OfCharacter, 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):
        _TColStd.TColStd_HArray1OfCharacter_swiginit(self, _TColStd.new_TColStd_HArray1OfCharacter(*args))

    def Array1(self) -> "TColStd_Array1OfCharacter const &":
        return _TColStd.TColStd_HArray1OfCharacter_Array1(self)

    def ChangeArray1(self) -> "TColStd_Array1OfCharacter &":
        return _TColStd.TColStd_HArray1OfCharacter_ChangeArray1(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfCharacter

# Register TColStd_HArray1OfCharacter in _TColStd:
_TColStd.TColStd_HArray1OfCharacter_swigregister(TColStd_HArray1OfCharacter)

class TColStd_HArray1OfBoolean(TColStd_Array1OfBoolean, 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):
        _TColStd.TColStd_HArray1OfBoolean_swiginit(self, _TColStd.new_TColStd_HArray1OfBoolean(*args))

    def Array1(self) -> "TColStd_Array1OfBoolean const &":
        return _TColStd.TColStd_HArray1OfBoolean_Array1(self)

    def ChangeArray1(self) -> "TColStd_Array1OfBoolean &":
        return _TColStd.TColStd_HArray1OfBoolean_ChangeArray1(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfBoolean

# Register TColStd_HArray1OfBoolean in _TColStd:
_TColStd.TColStd_HArray1OfBoolean_swigregister(TColStd_HArray1OfBoolean)

class TColStd_HArray1OfAsciiString(TColStd_Array1OfAsciiString, 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):
        _TColStd.TColStd_HArray1OfAsciiString_swiginit(self, _TColStd.new_TColStd_HArray1OfAsciiString(*args))

    def Array1(self) -> "TColStd_Array1OfAsciiString const &":
        return _TColStd.TColStd_HArray1OfAsciiString_Array1(self)

    def ChangeArray1(self) -> "TColStd_Array1OfAsciiString &":
        return _TColStd.TColStd_HArray1OfAsciiString_ChangeArray1(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfAsciiString

# Register TColStd_HArray1OfAsciiString in _TColStd:
_TColStd.TColStd_HArray1OfAsciiString_swigregister(TColStd_HArray1OfAsciiString)

class TColStd_HArray1OfReal(TColStd_Array1OfReal, 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):
        _TColStd.TColStd_HArray1OfReal_swiginit(self, _TColStd.new_TColStd_HArray1OfReal(*args))

    def Array1(self) -> "TColStd_Array1OfReal const &":
        return _TColStd.TColStd_HArray1OfReal_Array1(self)

    def ChangeArray1(self) -> "TColStd_Array1OfReal &":
        return _TColStd.TColStd_HArray1OfReal_ChangeArray1(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfReal

# Register TColStd_HArray1OfReal in _TColStd:
_TColStd.TColStd_HArray1OfReal_swigregister(TColStd_HArray1OfReal)

class TColStd_HArray1OfInteger(TColStd_Array1OfInteger, 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):
        _TColStd.TColStd_HArray1OfInteger_swiginit(self, _TColStd.new_TColStd_HArray1OfInteger(*args))

    def Array1(self) -> "TColStd_Array1OfInteger const &":
        return _TColStd.TColStd_HArray1OfInteger_Array1(self)

    def ChangeArray1(self) -> "TColStd_Array1OfInteger &":
        return _TColStd.TColStd_HArray1OfInteger_ChangeArray1(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfInteger

# Register TColStd_HArray1OfInteger in _TColStd:
_TColStd.TColStd_HArray1OfInteger_swigregister(TColStd_HArray1OfInteger)

class TColStd_HArray1OfListOfInteger(TColStd_Array1OfListOfInteger, 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):
        _TColStd.TColStd_HArray1OfListOfInteger_swiginit(self, _TColStd.new_TColStd_HArray1OfListOfInteger(*args))

    def Array1(self) -> "TColStd_Array1OfListOfInteger const &":
        return _TColStd.TColStd_HArray1OfListOfInteger_Array1(self)

    def ChangeArray1(self) -> "TColStd_Array1OfListOfInteger &":
        return _TColStd.TColStd_HArray1OfListOfInteger_ChangeArray1(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfListOfInteger

# Register TColStd_HArray1OfListOfInteger in _TColStd:
_TColStd.TColStd_HArray1OfListOfInteger_swigregister(TColStd_HArray1OfListOfInteger)

class TColStd_HArray1OfTransient(TColStd_Array1OfTransient, 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):
        _TColStd.TColStd_HArray1OfTransient_swiginit(self, _TColStd.new_TColStd_HArray1OfTransient(*args))

    def Array1(self) -> "TColStd_Array1OfTransient const &":
        return _TColStd.TColStd_HArray1OfTransient_Array1(self)

    def ChangeArray1(self) -> "TColStd_Array1OfTransient &":
        return _TColStd.TColStd_HArray1OfTransient_ChangeArray1(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfTransient

# Register TColStd_HArray1OfTransient in _TColStd:
_TColStd.TColStd_HArray1OfTransient_swigregister(TColStd_HArray1OfTransient)

class TColStd_HArray1OfByte(TColStd_Array1OfByte, 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):
        _TColStd.TColStd_HArray1OfByte_swiginit(self, _TColStd.new_TColStd_HArray1OfByte(*args))

    def Array1(self) -> "TColStd_Array1OfByte const &":
        return _TColStd.TColStd_HArray1OfByte_Array1(self)

    def ChangeArray1(self) -> "TColStd_Array1OfByte &":
        return _TColStd.TColStd_HArray1OfByte_ChangeArray1(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfByte

# Register TColStd_HArray1OfByte in _TColStd:
_TColStd.TColStd_HArray1OfByte_swigregister(TColStd_HArray1OfByte)

class TColStd_HArray2OfBoolean(TColStd_Array2OfBoolean, 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):
        _TColStd.TColStd_HArray2OfBoolean_swiginit(self, _TColStd.new_TColStd_HArray2OfBoolean(*args))

    def Array2(self) -> "TColStd_Array2OfBoolean const &":
        return _TColStd.TColStd_HArray2OfBoolean_Array2(self)

    def ChangeArray2(self) -> "TColStd_Array2OfBoolean &":
        return _TColStd.TColStd_HArray2OfBoolean_ChangeArray2(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfBoolean

# Register TColStd_HArray2OfBoolean in _TColStd:
_TColStd.TColStd_HArray2OfBoolean_swigregister(TColStd_HArray2OfBoolean)

class TColStd_HArray2OfTransient(TColStd_Array2OfTransient, 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):
        _TColStd.TColStd_HArray2OfTransient_swiginit(self, _TColStd.new_TColStd_HArray2OfTransient(*args))

    def Array2(self) -> "TColStd_Array2OfTransient const &":
        return _TColStd.TColStd_HArray2OfTransient_Array2(self)

    def ChangeArray2(self) -> "TColStd_Array2OfTransient &":
        return _TColStd.TColStd_HArray2OfTransient_ChangeArray2(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfTransient

# Register TColStd_HArray2OfTransient in _TColStd:
_TColStd.TColStd_HArray2OfTransient_swigregister(TColStd_HArray2OfTransient)

class TColStd_HArray2OfReal(TColStd_Array2OfReal, 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):
        _TColStd.TColStd_HArray2OfReal_swiginit(self, _TColStd.new_TColStd_HArray2OfReal(*args))

    def Array2(self) -> "TColStd_Array2OfReal const &":
        return _TColStd.TColStd_HArray2OfReal_Array2(self)

    def ChangeArray2(self) -> "TColStd_Array2OfReal &":
        return _TColStd.TColStd_HArray2OfReal_ChangeArray2(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfReal

# Register TColStd_HArray2OfReal in _TColStd:
_TColStd.TColStd_HArray2OfReal_swigregister(TColStd_HArray2OfReal)

class TColStd_HArray2OfInteger(TColStd_Array2OfInteger, 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):
        _TColStd.TColStd_HArray2OfInteger_swiginit(self, _TColStd.new_TColStd_HArray2OfInteger(*args))

    def Array2(self) -> "TColStd_Array2OfInteger const &":
        return _TColStd.TColStd_HArray2OfInteger_Array2(self)

    def ChangeArray2(self) -> "TColStd_Array2OfInteger &":
        return _TColStd.TColStd_HArray2OfInteger_ChangeArray2(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfInteger

# Register TColStd_HArray2OfInteger in _TColStd:
_TColStd.TColStd_HArray2OfInteger_swigregister(TColStd_HArray2OfInteger)

class TColStd_HArray2OfCharacter(TColStd_Array2OfCharacter, 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):
        _TColStd.TColStd_HArray2OfCharacter_swiginit(self, _TColStd.new_TColStd_HArray2OfCharacter(*args))

    def Array2(self) -> "TColStd_Array2OfCharacter const &":
        return _TColStd.TColStd_HArray2OfCharacter_Array2(self)

    def ChangeArray2(self) -> "TColStd_Array2OfCharacter &":
        return _TColStd.TColStd_HArray2OfCharacter_ChangeArray2(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfCharacter

# Register TColStd_HArray2OfCharacter in _TColStd:
_TColStd.TColStd_HArray2OfCharacter_swigregister(TColStd_HArray2OfCharacter)

class TColStd_HSequenceOfHAsciiString(TColStd_SequenceOfHAsciiString, 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):
        _TColStd.TColStd_HSequenceOfHAsciiString_swiginit(self, _TColStd.new_TColStd_HSequenceOfHAsciiString(*args))

    def Sequence(self) -> "TColStd_SequenceOfHAsciiString const &":
        return _TColStd.TColStd_HSequenceOfHAsciiString_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_HSequenceOfHAsciiString_Append(self, *args)

    def ChangeSequence(self) -> "TColStd_SequenceOfHAsciiString &":
        return _TColStd.TColStd_HSequenceOfHAsciiString_ChangeSequence(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfHAsciiString

# Register TColStd_HSequenceOfHAsciiString in _TColStd:
_TColStd.TColStd_HSequenceOfHAsciiString_swigregister(TColStd_HSequenceOfHAsciiString)

class TColStd_HSequenceOfTransient(TColStd_SequenceOfTransient, 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):
        _TColStd.TColStd_HSequenceOfTransient_swiginit(self, _TColStd.new_TColStd_HSequenceOfTransient(*args))

    def Sequence(self) -> "TColStd_SequenceOfTransient const &":
        return _TColStd.TColStd_HSequenceOfTransient_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_HSequenceOfTransient_Append(self, *args)

    def ChangeSequence(self) -> "TColStd_SequenceOfTransient &":
        return _TColStd.TColStd_HSequenceOfTransient_ChangeSequence(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfTransient

# Register TColStd_HSequenceOfTransient in _TColStd:
_TColStd.TColStd_HSequenceOfTransient_swigregister(TColStd_HSequenceOfTransient)

class TColStd_HSequenceOfAsciiString(TColStd_SequenceOfAsciiString, 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):
        _TColStd.TColStd_HSequenceOfAsciiString_swiginit(self, _TColStd.new_TColStd_HSequenceOfAsciiString(*args))

    def Sequence(self) -> "TColStd_SequenceOfAsciiString const &":
        return _TColStd.TColStd_HSequenceOfAsciiString_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_HSequenceOfAsciiString_Append(self, *args)

    def ChangeSequence(self) -> "TColStd_SequenceOfAsciiString &":
        return _TColStd.TColStd_HSequenceOfAsciiString_ChangeSequence(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfAsciiString

# Register TColStd_HSequenceOfAsciiString in _TColStd:
_TColStd.TColStd_HSequenceOfAsciiString_swigregister(TColStd_HSequenceOfAsciiString)

class TColStd_HSequenceOfHExtendedString(TColStd_SequenceOfHExtendedString, 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):
        _TColStd.TColStd_HSequenceOfHExtendedString_swiginit(self, _TColStd.new_TColStd_HSequenceOfHExtendedString(*args))

    def Sequence(self) -> "TColStd_SequenceOfHExtendedString const &":
        return _TColStd.TColStd_HSequenceOfHExtendedString_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_HSequenceOfHExtendedString_Append(self, *args)

    def ChangeSequence(self) -> "TColStd_SequenceOfHExtendedString &":
        return _TColStd.TColStd_HSequenceOfHExtendedString_ChangeSequence(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfHExtendedString

# Register TColStd_HSequenceOfHExtendedString in _TColStd:
_TColStd.TColStd_HSequenceOfHExtendedString_swigregister(TColStd_HSequenceOfHExtendedString)

class TColStd_HSequenceOfInteger(TColStd_SequenceOfInteger, 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):
        _TColStd.TColStd_HSequenceOfInteger_swiginit(self, _TColStd.new_TColStd_HSequenceOfInteger(*args))

    def Sequence(self) -> "TColStd_SequenceOfInteger const &":
        return _TColStd.TColStd_HSequenceOfInteger_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_HSequenceOfInteger_Append(self, *args)

    def ChangeSequence(self) -> "TColStd_SequenceOfInteger &":
        return _TColStd.TColStd_HSequenceOfInteger_ChangeSequence(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfInteger

# Register TColStd_HSequenceOfInteger in _TColStd:
_TColStd.TColStd_HSequenceOfInteger_swigregister(TColStd_HSequenceOfInteger)

class TColStd_HSequenceOfExtendedString(TColStd_SequenceOfExtendedString, 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):
        _TColStd.TColStd_HSequenceOfExtendedString_swiginit(self, _TColStd.new_TColStd_HSequenceOfExtendedString(*args))

    def Sequence(self) -> "TColStd_SequenceOfExtendedString const &":
        return _TColStd.TColStd_HSequenceOfExtendedString_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_HSequenceOfExtendedString_Append(self, *args)

    def ChangeSequence(self) -> "TColStd_SequenceOfExtendedString &":
        return _TColStd.TColStd_HSequenceOfExtendedString_ChangeSequence(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfExtendedString

# Register TColStd_HSequenceOfExtendedString in _TColStd:
_TColStd.TColStd_HSequenceOfExtendedString_swigregister(TColStd_HSequenceOfExtendedString)

class TColStd_HSequenceOfReal(TColStd_SequenceOfReal, 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):
        _TColStd.TColStd_HSequenceOfReal_swiginit(self, _TColStd.new_TColStd_HSequenceOfReal(*args))

    def Sequence(self) -> "TColStd_SequenceOfReal const &":
        return _TColStd.TColStd_HSequenceOfReal_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColStd.TColStd_HSequenceOfReal_Append(self, *args)

    def ChangeSequence(self) -> "TColStd_SequenceOfReal &":
        return _TColStd.TColStd_HSequenceOfReal_ChangeSequence(self)


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

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfReal

# Register TColStd_HSequenceOfReal in _TColStd:
_TColStd.TColStd_HSequenceOfReal_swigregister(TColStd_HSequenceOfReal)





