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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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




def Handle_TColgp_HArray1OfVec_Create() -> "opencascade::handle< TColgp_HArray1OfVec >":
    return _TColgp.Handle_TColgp_HArray1OfVec_Create()

def Handle_TColgp_HArray1OfVec_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfVec >":
    return _TColgp.Handle_TColgp_HArray1OfVec_DownCast(t)

def Handle_TColgp_HArray1OfVec_IsNull(t: "opencascade::handle< TColgp_HArray1OfVec > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfVec_IsNull(t)

def Handle_TColgp_HArray1OfXY_Create() -> "opencascade::handle< TColgp_HArray1OfXY >":
    return _TColgp.Handle_TColgp_HArray1OfXY_Create()

def Handle_TColgp_HArray1OfXY_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfXY >":
    return _TColgp.Handle_TColgp_HArray1OfXY_DownCast(t)

def Handle_TColgp_HArray1OfXY_IsNull(t: "opencascade::handle< TColgp_HArray1OfXY > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfXY_IsNull(t)

def Handle_TColgp_HArray1OfCirc2d_Create() -> "opencascade::handle< TColgp_HArray1OfCirc2d >":
    return _TColgp.Handle_TColgp_HArray1OfCirc2d_Create()

def Handle_TColgp_HArray1OfCirc2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfCirc2d >":
    return _TColgp.Handle_TColgp_HArray1OfCirc2d_DownCast(t)

def Handle_TColgp_HArray1OfCirc2d_IsNull(t: "opencascade::handle< TColgp_HArray1OfCirc2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfCirc2d_IsNull(t)

def Handle_TColgp_HArray1OfPnt2d_Create() -> "opencascade::handle< TColgp_HArray1OfPnt2d >":
    return _TColgp.Handle_TColgp_HArray1OfPnt2d_Create()

def Handle_TColgp_HArray1OfPnt2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfPnt2d >":
    return _TColgp.Handle_TColgp_HArray1OfPnt2d_DownCast(t)

def Handle_TColgp_HArray1OfPnt2d_IsNull(t: "opencascade::handle< TColgp_HArray1OfPnt2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfPnt2d_IsNull(t)

def Handle_TColgp_HArray1OfDir_Create() -> "opencascade::handle< TColgp_HArray1OfDir >":
    return _TColgp.Handle_TColgp_HArray1OfDir_Create()

def Handle_TColgp_HArray1OfDir_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfDir >":
    return _TColgp.Handle_TColgp_HArray1OfDir_DownCast(t)

def Handle_TColgp_HArray1OfDir_IsNull(t: "opencascade::handle< TColgp_HArray1OfDir > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfDir_IsNull(t)

def Handle_TColgp_HArray1OfLin2d_Create() -> "opencascade::handle< TColgp_HArray1OfLin2d >":
    return _TColgp.Handle_TColgp_HArray1OfLin2d_Create()

def Handle_TColgp_HArray1OfLin2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfLin2d >":
    return _TColgp.Handle_TColgp_HArray1OfLin2d_DownCast(t)

def Handle_TColgp_HArray1OfLin2d_IsNull(t: "opencascade::handle< TColgp_HArray1OfLin2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfLin2d_IsNull(t)

def Handle_TColgp_HArray1OfPnt_Create() -> "opencascade::handle< TColgp_HArray1OfPnt >":
    return _TColgp.Handle_TColgp_HArray1OfPnt_Create()

def Handle_TColgp_HArray1OfPnt_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfPnt >":
    return _TColgp.Handle_TColgp_HArray1OfPnt_DownCast(t)

def Handle_TColgp_HArray1OfPnt_IsNull(t: "opencascade::handle< TColgp_HArray1OfPnt > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfPnt_IsNull(t)

def Handle_TColgp_HArray1OfXYZ_Create() -> "opencascade::handle< TColgp_HArray1OfXYZ >":
    return _TColgp.Handle_TColgp_HArray1OfXYZ_Create()

def Handle_TColgp_HArray1OfXYZ_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfXYZ >":
    return _TColgp.Handle_TColgp_HArray1OfXYZ_DownCast(t)

def Handle_TColgp_HArray1OfXYZ_IsNull(t: "opencascade::handle< TColgp_HArray1OfXYZ > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfXYZ_IsNull(t)

def Handle_TColgp_HArray1OfVec2d_Create() -> "opencascade::handle< TColgp_HArray1OfVec2d >":
    return _TColgp.Handle_TColgp_HArray1OfVec2d_Create()

def Handle_TColgp_HArray1OfVec2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfVec2d >":
    return _TColgp.Handle_TColgp_HArray1OfVec2d_DownCast(t)

def Handle_TColgp_HArray1OfVec2d_IsNull(t: "opencascade::handle< TColgp_HArray1OfVec2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfVec2d_IsNull(t)

def Handle_TColgp_HArray1OfDir2d_Create() -> "opencascade::handle< TColgp_HArray1OfDir2d >":
    return _TColgp.Handle_TColgp_HArray1OfDir2d_Create()

def Handle_TColgp_HArray1OfDir2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray1OfDir2d >":
    return _TColgp.Handle_TColgp_HArray1OfDir2d_DownCast(t)

def Handle_TColgp_HArray1OfDir2d_IsNull(t: "opencascade::handle< TColgp_HArray1OfDir2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray1OfDir2d_IsNull(t)

def Handle_TColgp_HArray2OfLin2d_Create() -> "opencascade::handle< TColgp_HArray2OfLin2d >":
    return _TColgp.Handle_TColgp_HArray2OfLin2d_Create()

def Handle_TColgp_HArray2OfLin2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfLin2d >":
    return _TColgp.Handle_TColgp_HArray2OfLin2d_DownCast(t)

def Handle_TColgp_HArray2OfLin2d_IsNull(t: "opencascade::handle< TColgp_HArray2OfLin2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfLin2d_IsNull(t)

def Handle_TColgp_HArray2OfVec_Create() -> "opencascade::handle< TColgp_HArray2OfVec >":
    return _TColgp.Handle_TColgp_HArray2OfVec_Create()

def Handle_TColgp_HArray2OfVec_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfVec >":
    return _TColgp.Handle_TColgp_HArray2OfVec_DownCast(t)

def Handle_TColgp_HArray2OfVec_IsNull(t: "opencascade::handle< TColgp_HArray2OfVec > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfVec_IsNull(t)

def Handle_TColgp_HArray2OfCirc2d_Create() -> "opencascade::handle< TColgp_HArray2OfCirc2d >":
    return _TColgp.Handle_TColgp_HArray2OfCirc2d_Create()

def Handle_TColgp_HArray2OfCirc2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfCirc2d >":
    return _TColgp.Handle_TColgp_HArray2OfCirc2d_DownCast(t)

def Handle_TColgp_HArray2OfCirc2d_IsNull(t: "opencascade::handle< TColgp_HArray2OfCirc2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfCirc2d_IsNull(t)

def Handle_TColgp_HArray2OfPnt2d_Create() -> "opencascade::handle< TColgp_HArray2OfPnt2d >":
    return _TColgp.Handle_TColgp_HArray2OfPnt2d_Create()

def Handle_TColgp_HArray2OfPnt2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfPnt2d >":
    return _TColgp.Handle_TColgp_HArray2OfPnt2d_DownCast(t)

def Handle_TColgp_HArray2OfPnt2d_IsNull(t: "opencascade::handle< TColgp_HArray2OfPnt2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfPnt2d_IsNull(t)

def Handle_TColgp_HArray2OfDir2d_Create() -> "opencascade::handle< TColgp_HArray2OfDir2d >":
    return _TColgp.Handle_TColgp_HArray2OfDir2d_Create()

def Handle_TColgp_HArray2OfDir2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfDir2d >":
    return _TColgp.Handle_TColgp_HArray2OfDir2d_DownCast(t)

def Handle_TColgp_HArray2OfDir2d_IsNull(t: "opencascade::handle< TColgp_HArray2OfDir2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfDir2d_IsNull(t)

def Handle_TColgp_HArray2OfDir_Create() -> "opencascade::handle< TColgp_HArray2OfDir >":
    return _TColgp.Handle_TColgp_HArray2OfDir_Create()

def Handle_TColgp_HArray2OfDir_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfDir >":
    return _TColgp.Handle_TColgp_HArray2OfDir_DownCast(t)

def Handle_TColgp_HArray2OfDir_IsNull(t: "opencascade::handle< TColgp_HArray2OfDir > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfDir_IsNull(t)

def Handle_TColgp_HArray2OfPnt_Create() -> "opencascade::handle< TColgp_HArray2OfPnt >":
    return _TColgp.Handle_TColgp_HArray2OfPnt_Create()

def Handle_TColgp_HArray2OfPnt_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfPnt >":
    return _TColgp.Handle_TColgp_HArray2OfPnt_DownCast(t)

def Handle_TColgp_HArray2OfPnt_IsNull(t: "opencascade::handle< TColgp_HArray2OfPnt > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfPnt_IsNull(t)

def Handle_TColgp_HArray2OfVec2d_Create() -> "opencascade::handle< TColgp_HArray2OfVec2d >":
    return _TColgp.Handle_TColgp_HArray2OfVec2d_Create()

def Handle_TColgp_HArray2OfVec2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfVec2d >":
    return _TColgp.Handle_TColgp_HArray2OfVec2d_DownCast(t)

def Handle_TColgp_HArray2OfVec2d_IsNull(t: "opencascade::handle< TColgp_HArray2OfVec2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfVec2d_IsNull(t)

def Handle_TColgp_HArray2OfXYZ_Create() -> "opencascade::handle< TColgp_HArray2OfXYZ >":
    return _TColgp.Handle_TColgp_HArray2OfXYZ_Create()

def Handle_TColgp_HArray2OfXYZ_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfXYZ >":
    return _TColgp.Handle_TColgp_HArray2OfXYZ_DownCast(t)

def Handle_TColgp_HArray2OfXYZ_IsNull(t: "opencascade::handle< TColgp_HArray2OfXYZ > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfXYZ_IsNull(t)

def Handle_TColgp_HArray2OfXY_Create() -> "opencascade::handle< TColgp_HArray2OfXY >":
    return _TColgp.Handle_TColgp_HArray2OfXY_Create()

def Handle_TColgp_HArray2OfXY_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HArray2OfXY >":
    return _TColgp.Handle_TColgp_HArray2OfXY_DownCast(t)

def Handle_TColgp_HArray2OfXY_IsNull(t: "opencascade::handle< TColgp_HArray2OfXY > const &") -> "bool":
    return _TColgp.Handle_TColgp_HArray2OfXY_IsNull(t)

def Handle_TColgp_HSequenceOfXY_Create() -> "opencascade::handle< TColgp_HSequenceOfXY >":
    return _TColgp.Handle_TColgp_HSequenceOfXY_Create()

def Handle_TColgp_HSequenceOfXY_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HSequenceOfXY >":
    return _TColgp.Handle_TColgp_HSequenceOfXY_DownCast(t)

def Handle_TColgp_HSequenceOfXY_IsNull(t: "opencascade::handle< TColgp_HSequenceOfXY > const &") -> "bool":
    return _TColgp.Handle_TColgp_HSequenceOfXY_IsNull(t)

def Handle_TColgp_HSequenceOfPnt2d_Create() -> "opencascade::handle< TColgp_HSequenceOfPnt2d >":
    return _TColgp.Handle_TColgp_HSequenceOfPnt2d_Create()

def Handle_TColgp_HSequenceOfPnt2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HSequenceOfPnt2d >":
    return _TColgp.Handle_TColgp_HSequenceOfPnt2d_DownCast(t)

def Handle_TColgp_HSequenceOfPnt2d_IsNull(t: "opencascade::handle< TColgp_HSequenceOfPnt2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HSequenceOfPnt2d_IsNull(t)

def Handle_TColgp_HSequenceOfPnt_Create() -> "opencascade::handle< TColgp_HSequenceOfPnt >":
    return _TColgp.Handle_TColgp_HSequenceOfPnt_Create()

def Handle_TColgp_HSequenceOfPnt_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HSequenceOfPnt >":
    return _TColgp.Handle_TColgp_HSequenceOfPnt_DownCast(t)

def Handle_TColgp_HSequenceOfPnt_IsNull(t: "opencascade::handle< TColgp_HSequenceOfPnt > const &") -> "bool":
    return _TColgp.Handle_TColgp_HSequenceOfPnt_IsNull(t)

def Handle_TColgp_HSequenceOfXYZ_Create() -> "opencascade::handle< TColgp_HSequenceOfXYZ >":
    return _TColgp.Handle_TColgp_HSequenceOfXYZ_Create()

def Handle_TColgp_HSequenceOfXYZ_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HSequenceOfXYZ >":
    return _TColgp.Handle_TColgp_HSequenceOfXYZ_DownCast(t)

def Handle_TColgp_HSequenceOfXYZ_IsNull(t: "opencascade::handle< TColgp_HSequenceOfXYZ > const &") -> "bool":
    return _TColgp.Handle_TColgp_HSequenceOfXYZ_IsNull(t)

def Handle_TColgp_HSequenceOfVec2d_Create() -> "opencascade::handle< TColgp_HSequenceOfVec2d >":
    return _TColgp.Handle_TColgp_HSequenceOfVec2d_Create()

def Handle_TColgp_HSequenceOfVec2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HSequenceOfVec2d >":
    return _TColgp.Handle_TColgp_HSequenceOfVec2d_DownCast(t)

def Handle_TColgp_HSequenceOfVec2d_IsNull(t: "opencascade::handle< TColgp_HSequenceOfVec2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HSequenceOfVec2d_IsNull(t)

def Handle_TColgp_HSequenceOfDir2d_Create() -> "opencascade::handle< TColgp_HSequenceOfDir2d >":
    return _TColgp.Handle_TColgp_HSequenceOfDir2d_Create()

def Handle_TColgp_HSequenceOfDir2d_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HSequenceOfDir2d >":
    return _TColgp.Handle_TColgp_HSequenceOfDir2d_DownCast(t)

def Handle_TColgp_HSequenceOfDir2d_IsNull(t: "opencascade::handle< TColgp_HSequenceOfDir2d > const &") -> "bool":
    return _TColgp.Handle_TColgp_HSequenceOfDir2d_IsNull(t)

def Handle_TColgp_HSequenceOfVec_Create() -> "opencascade::handle< TColgp_HSequenceOfVec >":
    return _TColgp.Handle_TColgp_HSequenceOfVec_Create()

def Handle_TColgp_HSequenceOfVec_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HSequenceOfVec >":
    return _TColgp.Handle_TColgp_HSequenceOfVec_DownCast(t)

def Handle_TColgp_HSequenceOfVec_IsNull(t: "opencascade::handle< TColgp_HSequenceOfVec > const &") -> "bool":
    return _TColgp.Handle_TColgp_HSequenceOfVec_IsNull(t)

def Handle_TColgp_HSequenceOfDir_Create() -> "opencascade::handle< TColgp_HSequenceOfDir >":
    return _TColgp.Handle_TColgp_HSequenceOfDir_Create()

def Handle_TColgp_HSequenceOfDir_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< TColgp_HSequenceOfDir >":
    return _TColgp.Handle_TColgp_HSequenceOfDir_DownCast(t)

def Handle_TColgp_HSequenceOfDir_IsNull(t: "opencascade::handle< TColgp_HSequenceOfDir > const &") -> "bool":
    return _TColgp.Handle_TColgp_HSequenceOfDir_IsNull(t)
class TColgp_Array1OfCirc2d(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< gp_Circ2d >::iterator":
        return _TColgp.TColgp_Array1OfCirc2d_begin(self)

    def end(self) -> "NCollection_Array1< gp_Circ2d >::iterator":
        return _TColgp.TColgp_Array1OfCirc2d_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_Circ2d >::const_iterator":
        return _TColgp.TColgp_Array1OfCirc2d_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_Circ2d >::const_iterator":
        return _TColgp.TColgp_Array1OfCirc2d_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfCirc2d_swiginit(self, _TColgp.new_TColgp_Array1OfCirc2d(*args))

    def Init(self, theValue: "gp_Circ2d const &") -> "void":
        return _TColgp.TColgp_Array1OfCirc2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfCirc2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfCirc2d_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfCirc2d_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfCirc2d_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfCirc2d_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfCirc2d_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfCirc2d_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfCirc2d") -> "NCollection_Array1< gp_Circ2d > &":
        return _TColgp.TColgp_Array1OfCirc2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfCirc2d") -> "NCollection_Array1< gp_Circ2d > &":
        return _TColgp.TColgp_Array1OfCirc2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_Circ2d > &":
        return _TColgp.TColgp_Array1OfCirc2d_Set(self, *args)

    def First(self) -> "gp_Circ2d const &":
        return _TColgp.TColgp_Array1OfCirc2d_First(self)

    def ChangeFirst(self) -> "gp_Circ2d &":
        return _TColgp.TColgp_Array1OfCirc2d_ChangeFirst(self)

    def Last(self) -> "gp_Circ2d const &":
        return _TColgp.TColgp_Array1OfCirc2d_Last(self)

    def ChangeLast(self) -> "gp_Circ2d &":
        return _TColgp.TColgp_Array1OfCirc2d_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Circ2d const &":
        return _TColgp.TColgp_Array1OfCirc2d_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Circ2d &":
        return _TColgp.TColgp_Array1OfCirc2d_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Circ2d &":
        return _TColgp.TColgp_Array1OfCirc2d___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Circ2d const &") -> "void":
        return _TColgp.TColgp_Array1OfCirc2d_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfCirc2d_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfCirc2d

    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 TColgp_Array1OfCirc2d in _TColgp:
_TColgp.TColgp_Array1OfCirc2d_swigregister(TColgp_Array1OfCirc2d)

class TColgp_Array1OfDir(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< gp_Dir >::iterator":
        return _TColgp.TColgp_Array1OfDir_begin(self)

    def end(self) -> "NCollection_Array1< gp_Dir >::iterator":
        return _TColgp.TColgp_Array1OfDir_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_Dir >::const_iterator":
        return _TColgp.TColgp_Array1OfDir_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_Dir >::const_iterator":
        return _TColgp.TColgp_Array1OfDir_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfDir_swiginit(self, _TColgp.new_TColgp_Array1OfDir(*args))

    def Init(self, theValue: "gp_Dir const &") -> "void":
        return _TColgp.TColgp_Array1OfDir_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfDir_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfDir_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfDir_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfDir_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfDir_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfDir_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfDir_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfDir") -> "NCollection_Array1< gp_Dir > &":
        return _TColgp.TColgp_Array1OfDir_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfDir") -> "NCollection_Array1< gp_Dir > &":
        return _TColgp.TColgp_Array1OfDir_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_Dir > &":
        return _TColgp.TColgp_Array1OfDir_Set(self, *args)

    def First(self) -> "gp_Dir const &":
        return _TColgp.TColgp_Array1OfDir_First(self)

    def ChangeFirst(self) -> "gp_Dir &":
        return _TColgp.TColgp_Array1OfDir_ChangeFirst(self)

    def Last(self) -> "gp_Dir const &":
        return _TColgp.TColgp_Array1OfDir_Last(self)

    def ChangeLast(self) -> "gp_Dir &":
        return _TColgp.TColgp_Array1OfDir_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Dir const &":
        return _TColgp.TColgp_Array1OfDir_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Dir &":
        return _TColgp.TColgp_Array1OfDir_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Dir &":
        return _TColgp.TColgp_Array1OfDir___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Dir const &") -> "void":
        return _TColgp.TColgp_Array1OfDir_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfDir_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfDir

    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 TColgp_Array1OfDir in _TColgp:
_TColgp.TColgp_Array1OfDir_swigregister(TColgp_Array1OfDir)

class TColgp_Array1OfDir2d(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< gp_Dir2d >::iterator":
        return _TColgp.TColgp_Array1OfDir2d_begin(self)

    def end(self) -> "NCollection_Array1< gp_Dir2d >::iterator":
        return _TColgp.TColgp_Array1OfDir2d_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_Dir2d >::const_iterator":
        return _TColgp.TColgp_Array1OfDir2d_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_Dir2d >::const_iterator":
        return _TColgp.TColgp_Array1OfDir2d_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfDir2d_swiginit(self, _TColgp.new_TColgp_Array1OfDir2d(*args))

    def Init(self, theValue: "gp_Dir2d const &") -> "void":
        return _TColgp.TColgp_Array1OfDir2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfDir2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfDir2d_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfDir2d_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfDir2d_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfDir2d_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfDir2d_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfDir2d_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfDir2d") -> "NCollection_Array1< gp_Dir2d > &":
        return _TColgp.TColgp_Array1OfDir2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfDir2d") -> "NCollection_Array1< gp_Dir2d > &":
        return _TColgp.TColgp_Array1OfDir2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_Dir2d > &":
        return _TColgp.TColgp_Array1OfDir2d_Set(self, *args)

    def First(self) -> "gp_Dir2d const &":
        return _TColgp.TColgp_Array1OfDir2d_First(self)

    def ChangeFirst(self) -> "gp_Dir2d &":
        return _TColgp.TColgp_Array1OfDir2d_ChangeFirst(self)

    def Last(self) -> "gp_Dir2d const &":
        return _TColgp.TColgp_Array1OfDir2d_Last(self)

    def ChangeLast(self) -> "gp_Dir2d &":
        return _TColgp.TColgp_Array1OfDir2d_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Dir2d const &":
        return _TColgp.TColgp_Array1OfDir2d_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Dir2d &":
        return _TColgp.TColgp_Array1OfDir2d_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Dir2d &":
        return _TColgp.TColgp_Array1OfDir2d___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Dir2d const &") -> "void":
        return _TColgp.TColgp_Array1OfDir2d_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfDir2d_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfDir2d

    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 TColgp_Array1OfDir2d in _TColgp:
_TColgp.TColgp_Array1OfDir2d_swigregister(TColgp_Array1OfDir2d)

class TColgp_Array1OfLin2d(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< gp_Lin2d >::iterator":
        return _TColgp.TColgp_Array1OfLin2d_begin(self)

    def end(self) -> "NCollection_Array1< gp_Lin2d >::iterator":
        return _TColgp.TColgp_Array1OfLin2d_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_Lin2d >::const_iterator":
        return _TColgp.TColgp_Array1OfLin2d_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_Lin2d >::const_iterator":
        return _TColgp.TColgp_Array1OfLin2d_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfLin2d_swiginit(self, _TColgp.new_TColgp_Array1OfLin2d(*args))

    def Init(self, theValue: "gp_Lin2d const &") -> "void":
        return _TColgp.TColgp_Array1OfLin2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfLin2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfLin2d_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfLin2d_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfLin2d_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfLin2d_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfLin2d_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfLin2d_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfLin2d") -> "NCollection_Array1< gp_Lin2d > &":
        return _TColgp.TColgp_Array1OfLin2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfLin2d") -> "NCollection_Array1< gp_Lin2d > &":
        return _TColgp.TColgp_Array1OfLin2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_Lin2d > &":
        return _TColgp.TColgp_Array1OfLin2d_Set(self, *args)

    def First(self) -> "gp_Lin2d const &":
        return _TColgp.TColgp_Array1OfLin2d_First(self)

    def ChangeFirst(self) -> "gp_Lin2d &":
        return _TColgp.TColgp_Array1OfLin2d_ChangeFirst(self)

    def Last(self) -> "gp_Lin2d const &":
        return _TColgp.TColgp_Array1OfLin2d_Last(self)

    def ChangeLast(self) -> "gp_Lin2d &":
        return _TColgp.TColgp_Array1OfLin2d_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Lin2d const &":
        return _TColgp.TColgp_Array1OfLin2d_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Lin2d &":
        return _TColgp.TColgp_Array1OfLin2d_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Lin2d &":
        return _TColgp.TColgp_Array1OfLin2d___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Lin2d const &") -> "void":
        return _TColgp.TColgp_Array1OfLin2d_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfLin2d_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfLin2d

    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 TColgp_Array1OfLin2d in _TColgp:
_TColgp.TColgp_Array1OfLin2d_swigregister(TColgp_Array1OfLin2d)

class TColgp_Array1OfPnt(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< gp_Pnt >::iterator":
        return _TColgp.TColgp_Array1OfPnt_begin(self)

    def end(self) -> "NCollection_Array1< gp_Pnt >::iterator":
        return _TColgp.TColgp_Array1OfPnt_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_Pnt >::const_iterator":
        return _TColgp.TColgp_Array1OfPnt_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_Pnt >::const_iterator":
        return _TColgp.TColgp_Array1OfPnt_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfPnt_swiginit(self, _TColgp.new_TColgp_Array1OfPnt(*args))

    def Init(self, theValue: "gp_Pnt const &") -> "void":
        return _TColgp.TColgp_Array1OfPnt_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfPnt_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfPnt_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfPnt_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfPnt_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfPnt_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfPnt_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfPnt_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfPnt") -> "NCollection_Array1< gp_Pnt > &":
        return _TColgp.TColgp_Array1OfPnt_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfPnt") -> "NCollection_Array1< gp_Pnt > &":
        return _TColgp.TColgp_Array1OfPnt_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_Pnt > &":
        return _TColgp.TColgp_Array1OfPnt_Set(self, *args)

    def First(self) -> "gp_Pnt const &":
        return _TColgp.TColgp_Array1OfPnt_First(self)

    def ChangeFirst(self) -> "gp_Pnt &":
        return _TColgp.TColgp_Array1OfPnt_ChangeFirst(self)

    def Last(self) -> "gp_Pnt const &":
        return _TColgp.TColgp_Array1OfPnt_Last(self)

    def ChangeLast(self) -> "gp_Pnt &":
        return _TColgp.TColgp_Array1OfPnt_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Pnt const &":
        return _TColgp.TColgp_Array1OfPnt_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Pnt &":
        return _TColgp.TColgp_Array1OfPnt_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Pnt &":
        return _TColgp.TColgp_Array1OfPnt___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Pnt const &") -> "void":
        return _TColgp.TColgp_Array1OfPnt_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfPnt_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfPnt

    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 TColgp_Array1OfPnt in _TColgp:
_TColgp.TColgp_Array1OfPnt_swigregister(TColgp_Array1OfPnt)

class TColgp_Array1OfPnt2d(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< gp_Pnt2d >::iterator":
        return _TColgp.TColgp_Array1OfPnt2d_begin(self)

    def end(self) -> "NCollection_Array1< gp_Pnt2d >::iterator":
        return _TColgp.TColgp_Array1OfPnt2d_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_Pnt2d >::const_iterator":
        return _TColgp.TColgp_Array1OfPnt2d_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_Pnt2d >::const_iterator":
        return _TColgp.TColgp_Array1OfPnt2d_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfPnt2d_swiginit(self, _TColgp.new_TColgp_Array1OfPnt2d(*args))

    def Init(self, theValue: "gp_Pnt2d const &") -> "void":
        return _TColgp.TColgp_Array1OfPnt2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfPnt2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfPnt2d_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfPnt2d_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfPnt2d_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfPnt2d_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfPnt2d_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfPnt2d_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfPnt2d") -> "NCollection_Array1< gp_Pnt2d > &":
        return _TColgp.TColgp_Array1OfPnt2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfPnt2d") -> "NCollection_Array1< gp_Pnt2d > &":
        return _TColgp.TColgp_Array1OfPnt2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_Pnt2d > &":
        return _TColgp.TColgp_Array1OfPnt2d_Set(self, *args)

    def First(self) -> "gp_Pnt2d const &":
        return _TColgp.TColgp_Array1OfPnt2d_First(self)

    def ChangeFirst(self) -> "gp_Pnt2d &":
        return _TColgp.TColgp_Array1OfPnt2d_ChangeFirst(self)

    def Last(self) -> "gp_Pnt2d const &":
        return _TColgp.TColgp_Array1OfPnt2d_Last(self)

    def ChangeLast(self) -> "gp_Pnt2d &":
        return _TColgp.TColgp_Array1OfPnt2d_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Pnt2d const &":
        return _TColgp.TColgp_Array1OfPnt2d_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Pnt2d &":
        return _TColgp.TColgp_Array1OfPnt2d_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Pnt2d &":
        return _TColgp.TColgp_Array1OfPnt2d___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Pnt2d const &") -> "void":
        return _TColgp.TColgp_Array1OfPnt2d_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfPnt2d_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfPnt2d

    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 TColgp_Array1OfPnt2d in _TColgp:
_TColgp.TColgp_Array1OfPnt2d_swigregister(TColgp_Array1OfPnt2d)

class TColgp_Array1OfVec(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< gp_Vec >::iterator":
        return _TColgp.TColgp_Array1OfVec_begin(self)

    def end(self) -> "NCollection_Array1< gp_Vec >::iterator":
        return _TColgp.TColgp_Array1OfVec_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_Vec >::const_iterator":
        return _TColgp.TColgp_Array1OfVec_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_Vec >::const_iterator":
        return _TColgp.TColgp_Array1OfVec_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfVec_swiginit(self, _TColgp.new_TColgp_Array1OfVec(*args))

    def Init(self, theValue: "gp_Vec const &") -> "void":
        return _TColgp.TColgp_Array1OfVec_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfVec_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfVec_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfVec_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfVec_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfVec_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfVec_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfVec_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfVec") -> "NCollection_Array1< gp_Vec > &":
        return _TColgp.TColgp_Array1OfVec_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfVec") -> "NCollection_Array1< gp_Vec > &":
        return _TColgp.TColgp_Array1OfVec_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_Vec > &":
        return _TColgp.TColgp_Array1OfVec_Set(self, *args)

    def First(self) -> "gp_Vec const &":
        return _TColgp.TColgp_Array1OfVec_First(self)

    def ChangeFirst(self) -> "gp_Vec &":
        return _TColgp.TColgp_Array1OfVec_ChangeFirst(self)

    def Last(self) -> "gp_Vec const &":
        return _TColgp.TColgp_Array1OfVec_Last(self)

    def ChangeLast(self) -> "gp_Vec &":
        return _TColgp.TColgp_Array1OfVec_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Vec const &":
        return _TColgp.TColgp_Array1OfVec_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Vec &":
        return _TColgp.TColgp_Array1OfVec_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Vec &":
        return _TColgp.TColgp_Array1OfVec___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Vec const &") -> "void":
        return _TColgp.TColgp_Array1OfVec_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfVec_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfVec

    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 TColgp_Array1OfVec in _TColgp:
_TColgp.TColgp_Array1OfVec_swigregister(TColgp_Array1OfVec)

class TColgp_Array1OfVec2d(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< gp_Vec2d >::iterator":
        return _TColgp.TColgp_Array1OfVec2d_begin(self)

    def end(self) -> "NCollection_Array1< gp_Vec2d >::iterator":
        return _TColgp.TColgp_Array1OfVec2d_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_Vec2d >::const_iterator":
        return _TColgp.TColgp_Array1OfVec2d_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_Vec2d >::const_iterator":
        return _TColgp.TColgp_Array1OfVec2d_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfVec2d_swiginit(self, _TColgp.new_TColgp_Array1OfVec2d(*args))

    def Init(self, theValue: "gp_Vec2d const &") -> "void":
        return _TColgp.TColgp_Array1OfVec2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfVec2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfVec2d_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfVec2d_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfVec2d_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfVec2d_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfVec2d_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfVec2d_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfVec2d") -> "NCollection_Array1< gp_Vec2d > &":
        return _TColgp.TColgp_Array1OfVec2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfVec2d") -> "NCollection_Array1< gp_Vec2d > &":
        return _TColgp.TColgp_Array1OfVec2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_Vec2d > &":
        return _TColgp.TColgp_Array1OfVec2d_Set(self, *args)

    def First(self) -> "gp_Vec2d const &":
        return _TColgp.TColgp_Array1OfVec2d_First(self)

    def ChangeFirst(self) -> "gp_Vec2d &":
        return _TColgp.TColgp_Array1OfVec2d_ChangeFirst(self)

    def Last(self) -> "gp_Vec2d const &":
        return _TColgp.TColgp_Array1OfVec2d_Last(self)

    def ChangeLast(self) -> "gp_Vec2d &":
        return _TColgp.TColgp_Array1OfVec2d_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Vec2d const &":
        return _TColgp.TColgp_Array1OfVec2d_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Vec2d &":
        return _TColgp.TColgp_Array1OfVec2d_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Vec2d &":
        return _TColgp.TColgp_Array1OfVec2d___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Vec2d const &") -> "void":
        return _TColgp.TColgp_Array1OfVec2d_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfVec2d_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfVec2d

    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 TColgp_Array1OfVec2d in _TColgp:
_TColgp.TColgp_Array1OfVec2d_swigregister(TColgp_Array1OfVec2d)

class TColgp_Array1OfXY(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< gp_XY >::iterator":
        return _TColgp.TColgp_Array1OfXY_begin(self)

    def end(self) -> "NCollection_Array1< gp_XY >::iterator":
        return _TColgp.TColgp_Array1OfXY_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_XY >::const_iterator":
        return _TColgp.TColgp_Array1OfXY_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_XY >::const_iterator":
        return _TColgp.TColgp_Array1OfXY_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfXY_swiginit(self, _TColgp.new_TColgp_Array1OfXY(*args))

    def Init(self, theValue: "gp_XY const &") -> "void":
        return _TColgp.TColgp_Array1OfXY_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfXY_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfXY_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfXY_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfXY_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfXY_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfXY_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfXY_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfXY") -> "NCollection_Array1< gp_XY > &":
        return _TColgp.TColgp_Array1OfXY_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfXY") -> "NCollection_Array1< gp_XY > &":
        return _TColgp.TColgp_Array1OfXY_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_XY > &":
        return _TColgp.TColgp_Array1OfXY_Set(self, *args)

    def First(self) -> "gp_XY const &":
        return _TColgp.TColgp_Array1OfXY_First(self)

    def ChangeFirst(self) -> "gp_XY &":
        return _TColgp.TColgp_Array1OfXY_ChangeFirst(self)

    def Last(self) -> "gp_XY const &":
        return _TColgp.TColgp_Array1OfXY_Last(self)

    def ChangeLast(self) -> "gp_XY &":
        return _TColgp.TColgp_Array1OfXY_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_XY const &":
        return _TColgp.TColgp_Array1OfXY_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_XY &":
        return _TColgp.TColgp_Array1OfXY_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_XY &":
        return _TColgp.TColgp_Array1OfXY___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_XY const &") -> "void":
        return _TColgp.TColgp_Array1OfXY_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfXY_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfXY

    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 TColgp_Array1OfXY in _TColgp:
_TColgp.TColgp_Array1OfXY_swigregister(TColgp_Array1OfXY)

class TColgp_Array1OfXYZ(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< gp_XYZ >::iterator":
        return _TColgp.TColgp_Array1OfXYZ_begin(self)

    def end(self) -> "NCollection_Array1< gp_XYZ >::iterator":
        return _TColgp.TColgp_Array1OfXYZ_end(self)

    def cbegin(self) -> "NCollection_Array1< gp_XYZ >::const_iterator":
        return _TColgp.TColgp_Array1OfXYZ_cbegin(self)

    def cend(self) -> "NCollection_Array1< gp_XYZ >::const_iterator":
        return _TColgp.TColgp_Array1OfXYZ_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_Array1OfXYZ_swiginit(self, _TColgp.new_TColgp_Array1OfXYZ(*args))

    def Init(self, theValue: "gp_XYZ const &") -> "void":
        return _TColgp.TColgp_Array1OfXYZ_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfXYZ_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfXYZ_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfXYZ_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfXYZ_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array1OfXYZ_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfXYZ_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array1OfXYZ_IsAllocated(self)

    def Assign(self, theOther: "TColgp_Array1OfXYZ") -> "NCollection_Array1< gp_XYZ > &":
        return _TColgp.TColgp_Array1OfXYZ_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array1OfXYZ") -> "NCollection_Array1< gp_XYZ > &":
        return _TColgp.TColgp_Array1OfXYZ_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< gp_XYZ > &":
        return _TColgp.TColgp_Array1OfXYZ_Set(self, *args)

    def First(self) -> "gp_XYZ const &":
        return _TColgp.TColgp_Array1OfXYZ_First(self)

    def ChangeFirst(self) -> "gp_XYZ &":
        return _TColgp.TColgp_Array1OfXYZ_ChangeFirst(self)

    def Last(self) -> "gp_XYZ const &":
        return _TColgp.TColgp_Array1OfXYZ_Last(self)

    def ChangeLast(self) -> "gp_XYZ &":
        return _TColgp.TColgp_Array1OfXYZ_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_XYZ const &":
        return _TColgp.TColgp_Array1OfXYZ_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_XYZ &":
        return _TColgp.TColgp_Array1OfXYZ_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_XYZ &":
        return _TColgp.TColgp_Array1OfXYZ___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_XYZ const &") -> "void":
        return _TColgp.TColgp_Array1OfXYZ_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _TColgp.TColgp_Array1OfXYZ_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array1OfXYZ

    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 TColgp_Array1OfXYZ in _TColgp:
_TColgp.TColgp_Array1OfXYZ_swigregister(TColgp_Array1OfXYZ)

class TColgp_Array2OfCirc2d(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):
        _TColgp.TColgp_Array2OfCirc2d_swiginit(self, _TColgp.new_TColgp_Array2OfCirc2d(*args))

    def Init(self, theValue: "gp_Circ2d const &") -> "void":
        return _TColgp.TColgp_Array2OfCirc2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfCirc2d_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfCirc2d_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfCirc2d") -> "NCollection_Array2< gp_Circ2d > &":
        return _TColgp.TColgp_Array2OfCirc2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfCirc2d") -> "NCollection_Array2< gp_Circ2d > &":
        return _TColgp.TColgp_Array2OfCirc2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_Circ2d > &":
        return _TColgp.TColgp_Array2OfCirc2d_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Circ2d const &":
        return _TColgp.TColgp_Array2OfCirc2d_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Circ2d &":
        return _TColgp.TColgp_Array2OfCirc2d_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_Circ2d &":
        return _TColgp.TColgp_Array2OfCirc2d___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_Circ2d const &") -> "void":
        return _TColgp.TColgp_Array2OfCirc2d_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 _TColgp.TColgp_Array2OfCirc2d_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfCirc2d

# Register TColgp_Array2OfCirc2d in _TColgp:
_TColgp.TColgp_Array2OfCirc2d_swigregister(TColgp_Array2OfCirc2d)

class TColgp_Array2OfDir(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):
        _TColgp.TColgp_Array2OfDir_swiginit(self, _TColgp.new_TColgp_Array2OfDir(*args))

    def Init(self, theValue: "gp_Dir const &") -> "void":
        return _TColgp.TColgp_Array2OfDir_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfDir_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfDir") -> "NCollection_Array2< gp_Dir > &":
        return _TColgp.TColgp_Array2OfDir_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfDir") -> "NCollection_Array2< gp_Dir > &":
        return _TColgp.TColgp_Array2OfDir_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_Dir > &":
        return _TColgp.TColgp_Array2OfDir_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Dir const &":
        return _TColgp.TColgp_Array2OfDir_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Dir &":
        return _TColgp.TColgp_Array2OfDir_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_Dir &":
        return _TColgp.TColgp_Array2OfDir___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_Dir const &") -> "void":
        return _TColgp.TColgp_Array2OfDir_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 _TColgp.TColgp_Array2OfDir_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfDir

# Register TColgp_Array2OfDir in _TColgp:
_TColgp.TColgp_Array2OfDir_swigregister(TColgp_Array2OfDir)

class TColgp_Array2OfDir2d(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):
        _TColgp.TColgp_Array2OfDir2d_swiginit(self, _TColgp.new_TColgp_Array2OfDir2d(*args))

    def Init(self, theValue: "gp_Dir2d const &") -> "void":
        return _TColgp.TColgp_Array2OfDir2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfDir2d_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfDir2d_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfDir2d") -> "NCollection_Array2< gp_Dir2d > &":
        return _TColgp.TColgp_Array2OfDir2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfDir2d") -> "NCollection_Array2< gp_Dir2d > &":
        return _TColgp.TColgp_Array2OfDir2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_Dir2d > &":
        return _TColgp.TColgp_Array2OfDir2d_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Dir2d const &":
        return _TColgp.TColgp_Array2OfDir2d_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Dir2d &":
        return _TColgp.TColgp_Array2OfDir2d_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_Dir2d &":
        return _TColgp.TColgp_Array2OfDir2d___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_Dir2d const &") -> "void":
        return _TColgp.TColgp_Array2OfDir2d_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 _TColgp.TColgp_Array2OfDir2d_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfDir2d

# Register TColgp_Array2OfDir2d in _TColgp:
_TColgp.TColgp_Array2OfDir2d_swigregister(TColgp_Array2OfDir2d)

class TColgp_Array2OfLin2d(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):
        _TColgp.TColgp_Array2OfLin2d_swiginit(self, _TColgp.new_TColgp_Array2OfLin2d(*args))

    def Init(self, theValue: "gp_Lin2d const &") -> "void":
        return _TColgp.TColgp_Array2OfLin2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfLin2d_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfLin2d_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfLin2d") -> "NCollection_Array2< gp_Lin2d > &":
        return _TColgp.TColgp_Array2OfLin2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfLin2d") -> "NCollection_Array2< gp_Lin2d > &":
        return _TColgp.TColgp_Array2OfLin2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_Lin2d > &":
        return _TColgp.TColgp_Array2OfLin2d_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Lin2d const &":
        return _TColgp.TColgp_Array2OfLin2d_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Lin2d &":
        return _TColgp.TColgp_Array2OfLin2d_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_Lin2d &":
        return _TColgp.TColgp_Array2OfLin2d___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_Lin2d const &") -> "void":
        return _TColgp.TColgp_Array2OfLin2d_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 _TColgp.TColgp_Array2OfLin2d_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfLin2d

# Register TColgp_Array2OfLin2d in _TColgp:
_TColgp.TColgp_Array2OfLin2d_swigregister(TColgp_Array2OfLin2d)

class TColgp_Array2OfPnt(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):
        _TColgp.TColgp_Array2OfPnt_swiginit(self, _TColgp.new_TColgp_Array2OfPnt(*args))

    def Init(self, theValue: "gp_Pnt const &") -> "void":
        return _TColgp.TColgp_Array2OfPnt_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfPnt_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfPnt") -> "NCollection_Array2< gp_Pnt > &":
        return _TColgp.TColgp_Array2OfPnt_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfPnt") -> "NCollection_Array2< gp_Pnt > &":
        return _TColgp.TColgp_Array2OfPnt_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_Pnt > &":
        return _TColgp.TColgp_Array2OfPnt_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Pnt const &":
        return _TColgp.TColgp_Array2OfPnt_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Pnt &":
        return _TColgp.TColgp_Array2OfPnt_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_Pnt &":
        return _TColgp.TColgp_Array2OfPnt___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_Pnt const &") -> "void":
        return _TColgp.TColgp_Array2OfPnt_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 _TColgp.TColgp_Array2OfPnt_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfPnt

# Register TColgp_Array2OfPnt in _TColgp:
_TColgp.TColgp_Array2OfPnt_swigregister(TColgp_Array2OfPnt)

class TColgp_Array2OfPnt2d(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):
        _TColgp.TColgp_Array2OfPnt2d_swiginit(self, _TColgp.new_TColgp_Array2OfPnt2d(*args))

    def Init(self, theValue: "gp_Pnt2d const &") -> "void":
        return _TColgp.TColgp_Array2OfPnt2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfPnt2d_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfPnt2d_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfPnt2d") -> "NCollection_Array2< gp_Pnt2d > &":
        return _TColgp.TColgp_Array2OfPnt2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfPnt2d") -> "NCollection_Array2< gp_Pnt2d > &":
        return _TColgp.TColgp_Array2OfPnt2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_Pnt2d > &":
        return _TColgp.TColgp_Array2OfPnt2d_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Pnt2d const &":
        return _TColgp.TColgp_Array2OfPnt2d_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Pnt2d &":
        return _TColgp.TColgp_Array2OfPnt2d_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_Pnt2d &":
        return _TColgp.TColgp_Array2OfPnt2d___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_Pnt2d const &") -> "void":
        return _TColgp.TColgp_Array2OfPnt2d_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 _TColgp.TColgp_Array2OfPnt2d_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfPnt2d

# Register TColgp_Array2OfPnt2d in _TColgp:
_TColgp.TColgp_Array2OfPnt2d_swigregister(TColgp_Array2OfPnt2d)

class TColgp_Array2OfVec(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):
        _TColgp.TColgp_Array2OfVec_swiginit(self, _TColgp.new_TColgp_Array2OfVec(*args))

    def Init(self, theValue: "gp_Vec const &") -> "void":
        return _TColgp.TColgp_Array2OfVec_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfVec_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfVec") -> "NCollection_Array2< gp_Vec > &":
        return _TColgp.TColgp_Array2OfVec_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfVec") -> "NCollection_Array2< gp_Vec > &":
        return _TColgp.TColgp_Array2OfVec_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_Vec > &":
        return _TColgp.TColgp_Array2OfVec_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Vec const &":
        return _TColgp.TColgp_Array2OfVec_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Vec &":
        return _TColgp.TColgp_Array2OfVec_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_Vec &":
        return _TColgp.TColgp_Array2OfVec___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_Vec const &") -> "void":
        return _TColgp.TColgp_Array2OfVec_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 _TColgp.TColgp_Array2OfVec_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfVec

# Register TColgp_Array2OfVec in _TColgp:
_TColgp.TColgp_Array2OfVec_swigregister(TColgp_Array2OfVec)

class TColgp_Array2OfVec2d(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):
        _TColgp.TColgp_Array2OfVec2d_swiginit(self, _TColgp.new_TColgp_Array2OfVec2d(*args))

    def Init(self, theValue: "gp_Vec2d const &") -> "void":
        return _TColgp.TColgp_Array2OfVec2d_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfVec2d_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfVec2d_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfVec2d") -> "NCollection_Array2< gp_Vec2d > &":
        return _TColgp.TColgp_Array2OfVec2d_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfVec2d") -> "NCollection_Array2< gp_Vec2d > &":
        return _TColgp.TColgp_Array2OfVec2d_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_Vec2d > &":
        return _TColgp.TColgp_Array2OfVec2d_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Vec2d const &":
        return _TColgp.TColgp_Array2OfVec2d_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_Vec2d &":
        return _TColgp.TColgp_Array2OfVec2d_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_Vec2d &":
        return _TColgp.TColgp_Array2OfVec2d___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_Vec2d const &") -> "void":
        return _TColgp.TColgp_Array2OfVec2d_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 _TColgp.TColgp_Array2OfVec2d_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfVec2d

# Register TColgp_Array2OfVec2d in _TColgp:
_TColgp.TColgp_Array2OfVec2d_swigregister(TColgp_Array2OfVec2d)

class TColgp_Array2OfXY(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):
        _TColgp.TColgp_Array2OfXY_swiginit(self, _TColgp.new_TColgp_Array2OfXY(*args))

    def Init(self, theValue: "gp_XY const &") -> "void":
        return _TColgp.TColgp_Array2OfXY_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXY_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfXY_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfXY") -> "NCollection_Array2< gp_XY > &":
        return _TColgp.TColgp_Array2OfXY_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfXY") -> "NCollection_Array2< gp_XY > &":
        return _TColgp.TColgp_Array2OfXY_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_XY > &":
        return _TColgp.TColgp_Array2OfXY_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_XY const &":
        return _TColgp.TColgp_Array2OfXY_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_XY &":
        return _TColgp.TColgp_Array2OfXY_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_XY &":
        return _TColgp.TColgp_Array2OfXY___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_XY const &") -> "void":
        return _TColgp.TColgp_Array2OfXY_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 _TColgp.TColgp_Array2OfXY_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfXY

# Register TColgp_Array2OfXY in _TColgp:
_TColgp.TColgp_Array2OfXY_swigregister(TColgp_Array2OfXY)

class TColgp_Array2OfXYZ(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):
        _TColgp.TColgp_Array2OfXYZ_swiginit(self, _TColgp.new_TColgp_Array2OfXYZ(*args))

    def Init(self, theValue: "gp_XYZ const &") -> "void":
        return _TColgp.TColgp_Array2OfXYZ_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _TColgp.TColgp_Array2OfXYZ_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _TColgp.TColgp_Array2OfXYZ_IsDeletable(self)

    def Assign(self, theOther: "TColgp_Array2OfXYZ") -> "NCollection_Array2< gp_XYZ > &":
        return _TColgp.TColgp_Array2OfXYZ_Assign(self, theOther)

    def Move(self, theOther: "TColgp_Array2OfXYZ") -> "NCollection_Array2< gp_XYZ > &":
        return _TColgp.TColgp_Array2OfXYZ_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< gp_XYZ > &":
        return _TColgp.TColgp_Array2OfXYZ_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_XYZ const &":
        return _TColgp.TColgp_Array2OfXYZ_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "gp_XYZ &":
        return _TColgp.TColgp_Array2OfXYZ_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "gp_XYZ &":
        return _TColgp.TColgp_Array2OfXYZ___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "gp_XYZ const &") -> "void":
        return _TColgp.TColgp_Array2OfXYZ_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 _TColgp.TColgp_Array2OfXYZ_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColgp.delete_TColgp_Array2OfXYZ

# Register TColgp_Array2OfXYZ in _TColgp:
_TColgp.TColgp_Array2OfXYZ_swigregister(TColgp_Array2OfXYZ)

class TColgp_SequenceOfArray1OfPnt2d(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< TColgp_HArray1OfPnt2d > >::iterator":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< TColgp_HArray1OfPnt2d > >::iterator":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< TColgp_HArray1OfPnt2d > >::const_iterator":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< TColgp_HArray1OfPnt2d > >::const_iterator":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfArray1OfPnt2d_swiginit(self, _TColgp.new_TColgp_SequenceOfArray1OfPnt2d(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfArray1OfPnt2d") -> "NCollection_Sequence< opencascade::handle< TColgp_HArray1OfPnt2d > > &":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfArray1OfPnt2d") -> "NCollection_Sequence< opencascade::handle< TColgp_HArray1OfPnt2d > > &":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfArray1OfPnt2d") -> "void":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< TColgp_HArray1OfPnt2d > const &":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_First(self)

    def ChangeFirst(self) -> "opencascade::handle< TColgp_HArray1OfPnt2d > &":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< TColgp_HArray1OfPnt2d > const &":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Last(self)

    def ChangeLast(self) -> "opencascade::handle< TColgp_HArray1OfPnt2d > &":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< TColgp_HArray1OfPnt2d > const &":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< TColgp_HArray1OfPnt2d > &":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< TColgp_HArray1OfPnt2d > &":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< TColgp_HArray1OfPnt2d > const &") -> "void":
        return _TColgp.TColgp_SequenceOfArray1OfPnt2d_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfArray1OfPnt2d

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


# Register TColgp_SequenceOfArray1OfPnt2d in _TColgp:
_TColgp.TColgp_SequenceOfArray1OfPnt2d_swigregister(TColgp_SequenceOfArray1OfPnt2d)

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

class TColgp_SequenceOfAx1(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< gp_Ax1 >::iterator":
        return _TColgp.TColgp_SequenceOfAx1_begin(self)

    def end(self) -> "NCollection_Sequence< gp_Ax1 >::iterator":
        return _TColgp.TColgp_SequenceOfAx1_end(self)

    def cbegin(self) -> "NCollection_Sequence< gp_Ax1 >::const_iterator":
        return _TColgp.TColgp_SequenceOfAx1_cbegin(self)

    def cend(self) -> "NCollection_Sequence< gp_Ax1 >::const_iterator":
        return _TColgp.TColgp_SequenceOfAx1_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfAx1_swiginit(self, _TColgp.new_TColgp_SequenceOfAx1(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfAx1_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfAx1_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfAx1_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfAx1_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfAx1_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfAx1_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfAx1") -> "NCollection_Sequence< gp_Ax1 > &":
        return _TColgp.TColgp_SequenceOfAx1_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfAx1") -> "NCollection_Sequence< gp_Ax1 > &":
        return _TColgp.TColgp_SequenceOfAx1_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfAx1_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfAx1_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfAx1_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfAx1_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfAx1_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfAx1") -> "void":
        return _TColgp.TColgp_SequenceOfAx1_Split(self, theIndex, theSeq)

    def First(self) -> "gp_Ax1 const &":
        return _TColgp.TColgp_SequenceOfAx1_First(self)

    def ChangeFirst(self) -> "gp_Ax1 &":
        return _TColgp.TColgp_SequenceOfAx1_ChangeFirst(self)

    def Last(self) -> "gp_Ax1 const &":
        return _TColgp.TColgp_SequenceOfAx1_Last(self)

    def ChangeLast(self) -> "gp_Ax1 &":
        return _TColgp.TColgp_SequenceOfAx1_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Ax1 const &":
        return _TColgp.TColgp_SequenceOfAx1_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Ax1 &":
        return _TColgp.TColgp_SequenceOfAx1_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Ax1 &":
        return _TColgp.TColgp_SequenceOfAx1___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Ax1 const &") -> "void":
        return _TColgp.TColgp_SequenceOfAx1_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfAx1

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


# Register TColgp_SequenceOfAx1 in _TColgp:
_TColgp.TColgp_SequenceOfAx1_swigregister(TColgp_SequenceOfAx1)

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

class TColgp_SequenceOfDir(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< gp_Dir >::iterator":
        return _TColgp.TColgp_SequenceOfDir_begin(self)

    def end(self) -> "NCollection_Sequence< gp_Dir >::iterator":
        return _TColgp.TColgp_SequenceOfDir_end(self)

    def cbegin(self) -> "NCollection_Sequence< gp_Dir >::const_iterator":
        return _TColgp.TColgp_SequenceOfDir_cbegin(self)

    def cend(self) -> "NCollection_Sequence< gp_Dir >::const_iterator":
        return _TColgp.TColgp_SequenceOfDir_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfDir_swiginit(self, _TColgp.new_TColgp_SequenceOfDir(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfDir_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfDir_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfDir_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfDir_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfDir_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfDir_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfDir") -> "NCollection_Sequence< gp_Dir > &":
        return _TColgp.TColgp_SequenceOfDir_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfDir") -> "NCollection_Sequence< gp_Dir > &":
        return _TColgp.TColgp_SequenceOfDir_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfDir") -> "void":
        return _TColgp.TColgp_SequenceOfDir_Split(self, theIndex, theSeq)

    def First(self) -> "gp_Dir const &":
        return _TColgp.TColgp_SequenceOfDir_First(self)

    def ChangeFirst(self) -> "gp_Dir &":
        return _TColgp.TColgp_SequenceOfDir_ChangeFirst(self)

    def Last(self) -> "gp_Dir const &":
        return _TColgp.TColgp_SequenceOfDir_Last(self)

    def ChangeLast(self) -> "gp_Dir &":
        return _TColgp.TColgp_SequenceOfDir_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Dir const &":
        return _TColgp.TColgp_SequenceOfDir_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Dir &":
        return _TColgp.TColgp_SequenceOfDir_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Dir &":
        return _TColgp.TColgp_SequenceOfDir___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Dir const &") -> "void":
        return _TColgp.TColgp_SequenceOfDir_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfDir

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


# Register TColgp_SequenceOfDir in _TColgp:
_TColgp.TColgp_SequenceOfDir_swigregister(TColgp_SequenceOfDir)

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

class TColgp_SequenceOfDir2d(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< gp_Dir2d >::iterator":
        return _TColgp.TColgp_SequenceOfDir2d_begin(self)

    def end(self) -> "NCollection_Sequence< gp_Dir2d >::iterator":
        return _TColgp.TColgp_SequenceOfDir2d_end(self)

    def cbegin(self) -> "NCollection_Sequence< gp_Dir2d >::const_iterator":
        return _TColgp.TColgp_SequenceOfDir2d_cbegin(self)

    def cend(self) -> "NCollection_Sequence< gp_Dir2d >::const_iterator":
        return _TColgp.TColgp_SequenceOfDir2d_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfDir2d_swiginit(self, _TColgp.new_TColgp_SequenceOfDir2d(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfDir2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfDir2d_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfDir2d_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfDir2d_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfDir2d_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfDir2d_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfDir2d") -> "NCollection_Sequence< gp_Dir2d > &":
        return _TColgp.TColgp_SequenceOfDir2d_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfDir2d") -> "NCollection_Sequence< gp_Dir2d > &":
        return _TColgp.TColgp_SequenceOfDir2d_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir2d_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir2d_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir2d_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir2d_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfDir2d_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfDir2d") -> "void":
        return _TColgp.TColgp_SequenceOfDir2d_Split(self, theIndex, theSeq)

    def First(self) -> "gp_Dir2d const &":
        return _TColgp.TColgp_SequenceOfDir2d_First(self)

    def ChangeFirst(self) -> "gp_Dir2d &":
        return _TColgp.TColgp_SequenceOfDir2d_ChangeFirst(self)

    def Last(self) -> "gp_Dir2d const &":
        return _TColgp.TColgp_SequenceOfDir2d_Last(self)

    def ChangeLast(self) -> "gp_Dir2d &":
        return _TColgp.TColgp_SequenceOfDir2d_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Dir2d const &":
        return _TColgp.TColgp_SequenceOfDir2d_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Dir2d &":
        return _TColgp.TColgp_SequenceOfDir2d_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Dir2d &":
        return _TColgp.TColgp_SequenceOfDir2d___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Dir2d const &") -> "void":
        return _TColgp.TColgp_SequenceOfDir2d_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfDir2d

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


# Register TColgp_SequenceOfDir2d in _TColgp:
_TColgp.TColgp_SequenceOfDir2d_swigregister(TColgp_SequenceOfDir2d)

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

class TColgp_SequenceOfPnt(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< gp_Pnt >::iterator":
        return _TColgp.TColgp_SequenceOfPnt_begin(self)

    def end(self) -> "NCollection_Sequence< gp_Pnt >::iterator":
        return _TColgp.TColgp_SequenceOfPnt_end(self)

    def cbegin(self) -> "NCollection_Sequence< gp_Pnt >::const_iterator":
        return _TColgp.TColgp_SequenceOfPnt_cbegin(self)

    def cend(self) -> "NCollection_Sequence< gp_Pnt >::const_iterator":
        return _TColgp.TColgp_SequenceOfPnt_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfPnt_swiginit(self, _TColgp.new_TColgp_SequenceOfPnt(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfPnt_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfPnt_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfPnt_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfPnt_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfPnt_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfPnt_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfPnt") -> "NCollection_Sequence< gp_Pnt > &":
        return _TColgp.TColgp_SequenceOfPnt_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfPnt") -> "NCollection_Sequence< gp_Pnt > &":
        return _TColgp.TColgp_SequenceOfPnt_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfPnt") -> "void":
        return _TColgp.TColgp_SequenceOfPnt_Split(self, theIndex, theSeq)

    def First(self) -> "gp_Pnt const &":
        return _TColgp.TColgp_SequenceOfPnt_First(self)

    def ChangeFirst(self) -> "gp_Pnt &":
        return _TColgp.TColgp_SequenceOfPnt_ChangeFirst(self)

    def Last(self) -> "gp_Pnt const &":
        return _TColgp.TColgp_SequenceOfPnt_Last(self)

    def ChangeLast(self) -> "gp_Pnt &":
        return _TColgp.TColgp_SequenceOfPnt_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Pnt const &":
        return _TColgp.TColgp_SequenceOfPnt_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Pnt &":
        return _TColgp.TColgp_SequenceOfPnt_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Pnt &":
        return _TColgp.TColgp_SequenceOfPnt___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Pnt const &") -> "void":
        return _TColgp.TColgp_SequenceOfPnt_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfPnt

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


# Register TColgp_SequenceOfPnt in _TColgp:
_TColgp.TColgp_SequenceOfPnt_swigregister(TColgp_SequenceOfPnt)

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

class TColgp_SequenceOfPnt2d(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< gp_Pnt2d >::iterator":
        return _TColgp.TColgp_SequenceOfPnt2d_begin(self)

    def end(self) -> "NCollection_Sequence< gp_Pnt2d >::iterator":
        return _TColgp.TColgp_SequenceOfPnt2d_end(self)

    def cbegin(self) -> "NCollection_Sequence< gp_Pnt2d >::const_iterator":
        return _TColgp.TColgp_SequenceOfPnt2d_cbegin(self)

    def cend(self) -> "NCollection_Sequence< gp_Pnt2d >::const_iterator":
        return _TColgp.TColgp_SequenceOfPnt2d_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfPnt2d_swiginit(self, _TColgp.new_TColgp_SequenceOfPnt2d(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfPnt2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfPnt2d_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfPnt2d_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfPnt2d_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfPnt2d_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfPnt2d_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfPnt2d") -> "NCollection_Sequence< gp_Pnt2d > &":
        return _TColgp.TColgp_SequenceOfPnt2d_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfPnt2d") -> "NCollection_Sequence< gp_Pnt2d > &":
        return _TColgp.TColgp_SequenceOfPnt2d_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt2d_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt2d_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt2d_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt2d_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfPnt2d_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfPnt2d") -> "void":
        return _TColgp.TColgp_SequenceOfPnt2d_Split(self, theIndex, theSeq)

    def First(self) -> "gp_Pnt2d const &":
        return _TColgp.TColgp_SequenceOfPnt2d_First(self)

    def ChangeFirst(self) -> "gp_Pnt2d &":
        return _TColgp.TColgp_SequenceOfPnt2d_ChangeFirst(self)

    def Last(self) -> "gp_Pnt2d const &":
        return _TColgp.TColgp_SequenceOfPnt2d_Last(self)

    def ChangeLast(self) -> "gp_Pnt2d &":
        return _TColgp.TColgp_SequenceOfPnt2d_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Pnt2d const &":
        return _TColgp.TColgp_SequenceOfPnt2d_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Pnt2d &":
        return _TColgp.TColgp_SequenceOfPnt2d_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Pnt2d &":
        return _TColgp.TColgp_SequenceOfPnt2d___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Pnt2d const &") -> "void":
        return _TColgp.TColgp_SequenceOfPnt2d_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfPnt2d

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


# Register TColgp_SequenceOfPnt2d in _TColgp:
_TColgp.TColgp_SequenceOfPnt2d_swigregister(TColgp_SequenceOfPnt2d)

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

class TColgp_SequenceOfVec(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< gp_Vec >::iterator":
        return _TColgp.TColgp_SequenceOfVec_begin(self)

    def end(self) -> "NCollection_Sequence< gp_Vec >::iterator":
        return _TColgp.TColgp_SequenceOfVec_end(self)

    def cbegin(self) -> "NCollection_Sequence< gp_Vec >::const_iterator":
        return _TColgp.TColgp_SequenceOfVec_cbegin(self)

    def cend(self) -> "NCollection_Sequence< gp_Vec >::const_iterator":
        return _TColgp.TColgp_SequenceOfVec_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfVec_swiginit(self, _TColgp.new_TColgp_SequenceOfVec(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfVec_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfVec_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfVec_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfVec_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfVec_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfVec_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfVec") -> "NCollection_Sequence< gp_Vec > &":
        return _TColgp.TColgp_SequenceOfVec_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfVec") -> "NCollection_Sequence< gp_Vec > &":
        return _TColgp.TColgp_SequenceOfVec_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfVec") -> "void":
        return _TColgp.TColgp_SequenceOfVec_Split(self, theIndex, theSeq)

    def First(self) -> "gp_Vec const &":
        return _TColgp.TColgp_SequenceOfVec_First(self)

    def ChangeFirst(self) -> "gp_Vec &":
        return _TColgp.TColgp_SequenceOfVec_ChangeFirst(self)

    def Last(self) -> "gp_Vec const &":
        return _TColgp.TColgp_SequenceOfVec_Last(self)

    def ChangeLast(self) -> "gp_Vec &":
        return _TColgp.TColgp_SequenceOfVec_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Vec const &":
        return _TColgp.TColgp_SequenceOfVec_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Vec &":
        return _TColgp.TColgp_SequenceOfVec_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Vec &":
        return _TColgp.TColgp_SequenceOfVec___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Vec const &") -> "void":
        return _TColgp.TColgp_SequenceOfVec_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfVec

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


# Register TColgp_SequenceOfVec in _TColgp:
_TColgp.TColgp_SequenceOfVec_swigregister(TColgp_SequenceOfVec)

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

class TColgp_SequenceOfVec2d(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< gp_Vec2d >::iterator":
        return _TColgp.TColgp_SequenceOfVec2d_begin(self)

    def end(self) -> "NCollection_Sequence< gp_Vec2d >::iterator":
        return _TColgp.TColgp_SequenceOfVec2d_end(self)

    def cbegin(self) -> "NCollection_Sequence< gp_Vec2d >::const_iterator":
        return _TColgp.TColgp_SequenceOfVec2d_cbegin(self)

    def cend(self) -> "NCollection_Sequence< gp_Vec2d >::const_iterator":
        return _TColgp.TColgp_SequenceOfVec2d_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfVec2d_swiginit(self, _TColgp.new_TColgp_SequenceOfVec2d(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfVec2d_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfVec2d_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfVec2d_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfVec2d_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfVec2d_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfVec2d_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfVec2d") -> "NCollection_Sequence< gp_Vec2d > &":
        return _TColgp.TColgp_SequenceOfVec2d_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfVec2d") -> "NCollection_Sequence< gp_Vec2d > &":
        return _TColgp.TColgp_SequenceOfVec2d_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec2d_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec2d_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec2d_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec2d_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfVec2d_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfVec2d") -> "void":
        return _TColgp.TColgp_SequenceOfVec2d_Split(self, theIndex, theSeq)

    def First(self) -> "gp_Vec2d const &":
        return _TColgp.TColgp_SequenceOfVec2d_First(self)

    def ChangeFirst(self) -> "gp_Vec2d &":
        return _TColgp.TColgp_SequenceOfVec2d_ChangeFirst(self)

    def Last(self) -> "gp_Vec2d const &":
        return _TColgp.TColgp_SequenceOfVec2d_Last(self)

    def ChangeLast(self) -> "gp_Vec2d &":
        return _TColgp.TColgp_SequenceOfVec2d_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_Vec2d const &":
        return _TColgp.TColgp_SequenceOfVec2d_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_Vec2d &":
        return _TColgp.TColgp_SequenceOfVec2d_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_Vec2d &":
        return _TColgp.TColgp_SequenceOfVec2d___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_Vec2d const &") -> "void":
        return _TColgp.TColgp_SequenceOfVec2d_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfVec2d

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


# Register TColgp_SequenceOfVec2d in _TColgp:
_TColgp.TColgp_SequenceOfVec2d_swigregister(TColgp_SequenceOfVec2d)

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

class TColgp_SequenceOfXY(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< gp_XY >::iterator":
        return _TColgp.TColgp_SequenceOfXY_begin(self)

    def end(self) -> "NCollection_Sequence< gp_XY >::iterator":
        return _TColgp.TColgp_SequenceOfXY_end(self)

    def cbegin(self) -> "NCollection_Sequence< gp_XY >::const_iterator":
        return _TColgp.TColgp_SequenceOfXY_cbegin(self)

    def cend(self) -> "NCollection_Sequence< gp_XY >::const_iterator":
        return _TColgp.TColgp_SequenceOfXY_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfXY_swiginit(self, _TColgp.new_TColgp_SequenceOfXY(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfXY_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfXY_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfXY_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfXY_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfXY_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfXY_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfXY") -> "NCollection_Sequence< gp_XY > &":
        return _TColgp.TColgp_SequenceOfXY_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfXY") -> "NCollection_Sequence< gp_XY > &":
        return _TColgp.TColgp_SequenceOfXY_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXY_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXY_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXY_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXY_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXY_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfXY") -> "void":
        return _TColgp.TColgp_SequenceOfXY_Split(self, theIndex, theSeq)

    def First(self) -> "gp_XY const &":
        return _TColgp.TColgp_SequenceOfXY_First(self)

    def ChangeFirst(self) -> "gp_XY &":
        return _TColgp.TColgp_SequenceOfXY_ChangeFirst(self)

    def Last(self) -> "gp_XY const &":
        return _TColgp.TColgp_SequenceOfXY_Last(self)

    def ChangeLast(self) -> "gp_XY &":
        return _TColgp.TColgp_SequenceOfXY_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_XY const &":
        return _TColgp.TColgp_SequenceOfXY_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_XY &":
        return _TColgp.TColgp_SequenceOfXY_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_XY &":
        return _TColgp.TColgp_SequenceOfXY___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_XY const &") -> "void":
        return _TColgp.TColgp_SequenceOfXY_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfXY

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


# Register TColgp_SequenceOfXY in _TColgp:
_TColgp.TColgp_SequenceOfXY_swigregister(TColgp_SequenceOfXY)

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

class TColgp_SequenceOfXYZ(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< gp_XYZ >::iterator":
        return _TColgp.TColgp_SequenceOfXYZ_begin(self)

    def end(self) -> "NCollection_Sequence< gp_XYZ >::iterator":
        return _TColgp.TColgp_SequenceOfXYZ_end(self)

    def cbegin(self) -> "NCollection_Sequence< gp_XYZ >::const_iterator":
        return _TColgp.TColgp_SequenceOfXYZ_cbegin(self)

    def cend(self) -> "NCollection_Sequence< gp_XYZ >::const_iterator":
        return _TColgp.TColgp_SequenceOfXYZ_cend(self)

    def __init__(self, *args):
        _TColgp.TColgp_SequenceOfXYZ_swiginit(self, _TColgp.new_TColgp_SequenceOfXYZ(*args))

    def Size(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfXYZ_Size(self)

    def Length(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfXYZ_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfXYZ_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _TColgp.TColgp_SequenceOfXYZ_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _TColgp.TColgp_SequenceOfXYZ_IsEmpty(self)

    def Reverse(self) -> "void":
        return _TColgp.TColgp_SequenceOfXYZ_Reverse(self)

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

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

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

    def Assign(self, theOther: "TColgp_SequenceOfXYZ") -> "NCollection_Sequence< gp_XYZ > &":
        return _TColgp.TColgp_SequenceOfXYZ_Assign(self, theOther)

    def Set(self, theOther: "TColgp_SequenceOfXYZ") -> "NCollection_Sequence< gp_XYZ > &":
        return _TColgp.TColgp_SequenceOfXYZ_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXYZ_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXYZ_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXYZ_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXYZ_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _TColgp.TColgp_SequenceOfXYZ_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "TColgp_SequenceOfXYZ") -> "void":
        return _TColgp.TColgp_SequenceOfXYZ_Split(self, theIndex, theSeq)

    def First(self) -> "gp_XYZ const &":
        return _TColgp.TColgp_SequenceOfXYZ_First(self)

    def ChangeFirst(self) -> "gp_XYZ &":
        return _TColgp.TColgp_SequenceOfXYZ_ChangeFirst(self)

    def Last(self) -> "gp_XYZ const &":
        return _TColgp.TColgp_SequenceOfXYZ_Last(self)

    def ChangeLast(self) -> "gp_XYZ &":
        return _TColgp.TColgp_SequenceOfXYZ_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "gp_XYZ const &":
        return _TColgp.TColgp_SequenceOfXYZ_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "gp_XYZ &":
        return _TColgp.TColgp_SequenceOfXYZ_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "gp_XYZ &":
        return _TColgp.TColgp_SequenceOfXYZ___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "gp_XYZ const &") -> "void":
        return _TColgp.TColgp_SequenceOfXYZ_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColgp.delete_TColgp_SequenceOfXYZ

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


# Register TColgp_SequenceOfXYZ in _TColgp:
_TColgp.TColgp_SequenceOfXYZ_swigregister(TColgp_SequenceOfXYZ)

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

class TColgp_HArray1OfVec(TColgp_Array1OfVec, 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):
        _TColgp.TColgp_HArray1OfVec_swiginit(self, _TColgp.new_TColgp_HArray1OfVec(*args))

    def Array1(self) -> "TColgp_Array1OfVec const &":
        return _TColgp.TColgp_HArray1OfVec_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfVec &":
        return _TColgp.TColgp_HArray1OfVec_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfVec

# Register TColgp_HArray1OfVec in _TColgp:
_TColgp.TColgp_HArray1OfVec_swigregister(TColgp_HArray1OfVec)

class TColgp_HArray1OfXY(TColgp_Array1OfXY, 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):
        _TColgp.TColgp_HArray1OfXY_swiginit(self, _TColgp.new_TColgp_HArray1OfXY(*args))

    def Array1(self) -> "TColgp_Array1OfXY const &":
        return _TColgp.TColgp_HArray1OfXY_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfXY &":
        return _TColgp.TColgp_HArray1OfXY_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfXY

# Register TColgp_HArray1OfXY in _TColgp:
_TColgp.TColgp_HArray1OfXY_swigregister(TColgp_HArray1OfXY)

class TColgp_HArray1OfCirc2d(TColgp_Array1OfCirc2d, 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):
        _TColgp.TColgp_HArray1OfCirc2d_swiginit(self, _TColgp.new_TColgp_HArray1OfCirc2d(*args))

    def Array1(self) -> "TColgp_Array1OfCirc2d const &":
        return _TColgp.TColgp_HArray1OfCirc2d_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfCirc2d &":
        return _TColgp.TColgp_HArray1OfCirc2d_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfCirc2d

# Register TColgp_HArray1OfCirc2d in _TColgp:
_TColgp.TColgp_HArray1OfCirc2d_swigregister(TColgp_HArray1OfCirc2d)

class TColgp_HArray1OfPnt2d(TColgp_Array1OfPnt2d, 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):
        _TColgp.TColgp_HArray1OfPnt2d_swiginit(self, _TColgp.new_TColgp_HArray1OfPnt2d(*args))

    def Array1(self) -> "TColgp_Array1OfPnt2d const &":
        return _TColgp.TColgp_HArray1OfPnt2d_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfPnt2d &":
        return _TColgp.TColgp_HArray1OfPnt2d_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfPnt2d

# Register TColgp_HArray1OfPnt2d in _TColgp:
_TColgp.TColgp_HArray1OfPnt2d_swigregister(TColgp_HArray1OfPnt2d)

class TColgp_HArray1OfDir(TColgp_Array1OfDir, 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):
        _TColgp.TColgp_HArray1OfDir_swiginit(self, _TColgp.new_TColgp_HArray1OfDir(*args))

    def Array1(self) -> "TColgp_Array1OfDir const &":
        return _TColgp.TColgp_HArray1OfDir_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfDir &":
        return _TColgp.TColgp_HArray1OfDir_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfDir

# Register TColgp_HArray1OfDir in _TColgp:
_TColgp.TColgp_HArray1OfDir_swigregister(TColgp_HArray1OfDir)

class TColgp_HArray1OfLin2d(TColgp_Array1OfLin2d, 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):
        _TColgp.TColgp_HArray1OfLin2d_swiginit(self, _TColgp.new_TColgp_HArray1OfLin2d(*args))

    def Array1(self) -> "TColgp_Array1OfLin2d const &":
        return _TColgp.TColgp_HArray1OfLin2d_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfLin2d &":
        return _TColgp.TColgp_HArray1OfLin2d_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfLin2d

# Register TColgp_HArray1OfLin2d in _TColgp:
_TColgp.TColgp_HArray1OfLin2d_swigregister(TColgp_HArray1OfLin2d)

class TColgp_HArray1OfPnt(TColgp_Array1OfPnt, 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):
        _TColgp.TColgp_HArray1OfPnt_swiginit(self, _TColgp.new_TColgp_HArray1OfPnt(*args))

    def Array1(self) -> "TColgp_Array1OfPnt const &":
        return _TColgp.TColgp_HArray1OfPnt_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfPnt &":
        return _TColgp.TColgp_HArray1OfPnt_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfPnt

# Register TColgp_HArray1OfPnt in _TColgp:
_TColgp.TColgp_HArray1OfPnt_swigregister(TColgp_HArray1OfPnt)

class TColgp_HArray1OfXYZ(TColgp_Array1OfXYZ, 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):
        _TColgp.TColgp_HArray1OfXYZ_swiginit(self, _TColgp.new_TColgp_HArray1OfXYZ(*args))

    def Array1(self) -> "TColgp_Array1OfXYZ const &":
        return _TColgp.TColgp_HArray1OfXYZ_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfXYZ &":
        return _TColgp.TColgp_HArray1OfXYZ_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfXYZ

# Register TColgp_HArray1OfXYZ in _TColgp:
_TColgp.TColgp_HArray1OfXYZ_swigregister(TColgp_HArray1OfXYZ)

class TColgp_HArray1OfVec2d(TColgp_Array1OfVec2d, 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):
        _TColgp.TColgp_HArray1OfVec2d_swiginit(self, _TColgp.new_TColgp_HArray1OfVec2d(*args))

    def Array1(self) -> "TColgp_Array1OfVec2d const &":
        return _TColgp.TColgp_HArray1OfVec2d_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfVec2d &":
        return _TColgp.TColgp_HArray1OfVec2d_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfVec2d

# Register TColgp_HArray1OfVec2d in _TColgp:
_TColgp.TColgp_HArray1OfVec2d_swigregister(TColgp_HArray1OfVec2d)

class TColgp_HArray1OfDir2d(TColgp_Array1OfDir2d, 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):
        _TColgp.TColgp_HArray1OfDir2d_swiginit(self, _TColgp.new_TColgp_HArray1OfDir2d(*args))

    def Array1(self) -> "TColgp_Array1OfDir2d const &":
        return _TColgp.TColgp_HArray1OfDir2d_Array1(self)

    def ChangeArray1(self) -> "TColgp_Array1OfDir2d &":
        return _TColgp.TColgp_HArray1OfDir2d_ChangeArray1(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray1OfDir2d

# Register TColgp_HArray1OfDir2d in _TColgp:
_TColgp.TColgp_HArray1OfDir2d_swigregister(TColgp_HArray1OfDir2d)

class TColgp_HArray2OfLin2d(TColgp_Array2OfLin2d, 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):
        _TColgp.TColgp_HArray2OfLin2d_swiginit(self, _TColgp.new_TColgp_HArray2OfLin2d(*args))

    def Array2(self) -> "TColgp_Array2OfLin2d const &":
        return _TColgp.TColgp_HArray2OfLin2d_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfLin2d &":
        return _TColgp.TColgp_HArray2OfLin2d_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfLin2d

# Register TColgp_HArray2OfLin2d in _TColgp:
_TColgp.TColgp_HArray2OfLin2d_swigregister(TColgp_HArray2OfLin2d)

class TColgp_HArray2OfVec(TColgp_Array2OfVec, 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):
        _TColgp.TColgp_HArray2OfVec_swiginit(self, _TColgp.new_TColgp_HArray2OfVec(*args))

    def Array2(self) -> "TColgp_Array2OfVec const &":
        return _TColgp.TColgp_HArray2OfVec_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfVec &":
        return _TColgp.TColgp_HArray2OfVec_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfVec

# Register TColgp_HArray2OfVec in _TColgp:
_TColgp.TColgp_HArray2OfVec_swigregister(TColgp_HArray2OfVec)

class TColgp_HArray2OfCirc2d(TColgp_Array2OfCirc2d, 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):
        _TColgp.TColgp_HArray2OfCirc2d_swiginit(self, _TColgp.new_TColgp_HArray2OfCirc2d(*args))

    def Array2(self) -> "TColgp_Array2OfCirc2d const &":
        return _TColgp.TColgp_HArray2OfCirc2d_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfCirc2d &":
        return _TColgp.TColgp_HArray2OfCirc2d_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfCirc2d

# Register TColgp_HArray2OfCirc2d in _TColgp:
_TColgp.TColgp_HArray2OfCirc2d_swigregister(TColgp_HArray2OfCirc2d)

class TColgp_HArray2OfPnt2d(TColgp_Array2OfPnt2d, 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):
        _TColgp.TColgp_HArray2OfPnt2d_swiginit(self, _TColgp.new_TColgp_HArray2OfPnt2d(*args))

    def Array2(self) -> "TColgp_Array2OfPnt2d const &":
        return _TColgp.TColgp_HArray2OfPnt2d_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfPnt2d &":
        return _TColgp.TColgp_HArray2OfPnt2d_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfPnt2d

# Register TColgp_HArray2OfPnt2d in _TColgp:
_TColgp.TColgp_HArray2OfPnt2d_swigregister(TColgp_HArray2OfPnt2d)

class TColgp_HArray2OfDir2d(TColgp_Array2OfDir2d, 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):
        _TColgp.TColgp_HArray2OfDir2d_swiginit(self, _TColgp.new_TColgp_HArray2OfDir2d(*args))

    def Array2(self) -> "TColgp_Array2OfDir2d const &":
        return _TColgp.TColgp_HArray2OfDir2d_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfDir2d &":
        return _TColgp.TColgp_HArray2OfDir2d_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfDir2d

# Register TColgp_HArray2OfDir2d in _TColgp:
_TColgp.TColgp_HArray2OfDir2d_swigregister(TColgp_HArray2OfDir2d)

class TColgp_HArray2OfDir(TColgp_Array2OfDir, 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):
        _TColgp.TColgp_HArray2OfDir_swiginit(self, _TColgp.new_TColgp_HArray2OfDir(*args))

    def Array2(self) -> "TColgp_Array2OfDir const &":
        return _TColgp.TColgp_HArray2OfDir_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfDir &":
        return _TColgp.TColgp_HArray2OfDir_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfDir

# Register TColgp_HArray2OfDir in _TColgp:
_TColgp.TColgp_HArray2OfDir_swigregister(TColgp_HArray2OfDir)

class TColgp_HArray2OfPnt(TColgp_Array2OfPnt, 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):
        _TColgp.TColgp_HArray2OfPnt_swiginit(self, _TColgp.new_TColgp_HArray2OfPnt(*args))

    def Array2(self) -> "TColgp_Array2OfPnt const &":
        return _TColgp.TColgp_HArray2OfPnt_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfPnt &":
        return _TColgp.TColgp_HArray2OfPnt_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfPnt

# Register TColgp_HArray2OfPnt in _TColgp:
_TColgp.TColgp_HArray2OfPnt_swigregister(TColgp_HArray2OfPnt)

class TColgp_HArray2OfVec2d(TColgp_Array2OfVec2d, 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):
        _TColgp.TColgp_HArray2OfVec2d_swiginit(self, _TColgp.new_TColgp_HArray2OfVec2d(*args))

    def Array2(self) -> "TColgp_Array2OfVec2d const &":
        return _TColgp.TColgp_HArray2OfVec2d_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfVec2d &":
        return _TColgp.TColgp_HArray2OfVec2d_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfVec2d

# Register TColgp_HArray2OfVec2d in _TColgp:
_TColgp.TColgp_HArray2OfVec2d_swigregister(TColgp_HArray2OfVec2d)

class TColgp_HArray2OfXYZ(TColgp_Array2OfXYZ, 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):
        _TColgp.TColgp_HArray2OfXYZ_swiginit(self, _TColgp.new_TColgp_HArray2OfXYZ(*args))

    def Array2(self) -> "TColgp_Array2OfXYZ const &":
        return _TColgp.TColgp_HArray2OfXYZ_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfXYZ &":
        return _TColgp.TColgp_HArray2OfXYZ_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfXYZ

# Register TColgp_HArray2OfXYZ in _TColgp:
_TColgp.TColgp_HArray2OfXYZ_swigregister(TColgp_HArray2OfXYZ)

class TColgp_HArray2OfXY(TColgp_Array2OfXY, 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):
        _TColgp.TColgp_HArray2OfXY_swiginit(self, _TColgp.new_TColgp_HArray2OfXY(*args))

    def Array2(self) -> "TColgp_Array2OfXY const &":
        return _TColgp.TColgp_HArray2OfXY_Array2(self)

    def ChangeArray2(self) -> "TColgp_Array2OfXY &":
        return _TColgp.TColgp_HArray2OfXY_ChangeArray2(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HArray2OfXY

# Register TColgp_HArray2OfXY in _TColgp:
_TColgp.TColgp_HArray2OfXY_swigregister(TColgp_HArray2OfXY)

class TColgp_HSequenceOfXY(TColgp_SequenceOfXY, 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):
        _TColgp.TColgp_HSequenceOfXY_swiginit(self, _TColgp.new_TColgp_HSequenceOfXY(*args))

    def Sequence(self) -> "TColgp_SequenceOfXY const &":
        return _TColgp.TColgp_HSequenceOfXY_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_HSequenceOfXY_Append(self, *args)

    def ChangeSequence(self) -> "TColgp_SequenceOfXY &":
        return _TColgp.TColgp_HSequenceOfXY_ChangeSequence(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HSequenceOfXY

# Register TColgp_HSequenceOfXY in _TColgp:
_TColgp.TColgp_HSequenceOfXY_swigregister(TColgp_HSequenceOfXY)

class TColgp_HSequenceOfPnt2d(TColgp_SequenceOfPnt2d, 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):
        _TColgp.TColgp_HSequenceOfPnt2d_swiginit(self, _TColgp.new_TColgp_HSequenceOfPnt2d(*args))

    def Sequence(self) -> "TColgp_SequenceOfPnt2d const &":
        return _TColgp.TColgp_HSequenceOfPnt2d_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_HSequenceOfPnt2d_Append(self, *args)

    def ChangeSequence(self) -> "TColgp_SequenceOfPnt2d &":
        return _TColgp.TColgp_HSequenceOfPnt2d_ChangeSequence(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HSequenceOfPnt2d

# Register TColgp_HSequenceOfPnt2d in _TColgp:
_TColgp.TColgp_HSequenceOfPnt2d_swigregister(TColgp_HSequenceOfPnt2d)

class TColgp_HSequenceOfPnt(TColgp_SequenceOfPnt, 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):
        _TColgp.TColgp_HSequenceOfPnt_swiginit(self, _TColgp.new_TColgp_HSequenceOfPnt(*args))

    def Sequence(self) -> "TColgp_SequenceOfPnt const &":
        return _TColgp.TColgp_HSequenceOfPnt_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_HSequenceOfPnt_Append(self, *args)

    def ChangeSequence(self) -> "TColgp_SequenceOfPnt &":
        return _TColgp.TColgp_HSequenceOfPnt_ChangeSequence(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HSequenceOfPnt

# Register TColgp_HSequenceOfPnt in _TColgp:
_TColgp.TColgp_HSequenceOfPnt_swigregister(TColgp_HSequenceOfPnt)

class TColgp_HSequenceOfXYZ(TColgp_SequenceOfXYZ, 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):
        _TColgp.TColgp_HSequenceOfXYZ_swiginit(self, _TColgp.new_TColgp_HSequenceOfXYZ(*args))

    def Sequence(self) -> "TColgp_SequenceOfXYZ const &":
        return _TColgp.TColgp_HSequenceOfXYZ_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_HSequenceOfXYZ_Append(self, *args)

    def ChangeSequence(self) -> "TColgp_SequenceOfXYZ &":
        return _TColgp.TColgp_HSequenceOfXYZ_ChangeSequence(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HSequenceOfXYZ

# Register TColgp_HSequenceOfXYZ in _TColgp:
_TColgp.TColgp_HSequenceOfXYZ_swigregister(TColgp_HSequenceOfXYZ)

class TColgp_HSequenceOfVec2d(TColgp_SequenceOfVec2d, 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):
        _TColgp.TColgp_HSequenceOfVec2d_swiginit(self, _TColgp.new_TColgp_HSequenceOfVec2d(*args))

    def Sequence(self) -> "TColgp_SequenceOfVec2d const &":
        return _TColgp.TColgp_HSequenceOfVec2d_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_HSequenceOfVec2d_Append(self, *args)

    def ChangeSequence(self) -> "TColgp_SequenceOfVec2d &":
        return _TColgp.TColgp_HSequenceOfVec2d_ChangeSequence(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HSequenceOfVec2d

# Register TColgp_HSequenceOfVec2d in _TColgp:
_TColgp.TColgp_HSequenceOfVec2d_swigregister(TColgp_HSequenceOfVec2d)

class TColgp_HSequenceOfDir2d(TColgp_SequenceOfDir2d, 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):
        _TColgp.TColgp_HSequenceOfDir2d_swiginit(self, _TColgp.new_TColgp_HSequenceOfDir2d(*args))

    def Sequence(self) -> "TColgp_SequenceOfDir2d const &":
        return _TColgp.TColgp_HSequenceOfDir2d_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_HSequenceOfDir2d_Append(self, *args)

    def ChangeSequence(self) -> "TColgp_SequenceOfDir2d &":
        return _TColgp.TColgp_HSequenceOfDir2d_ChangeSequence(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HSequenceOfDir2d

# Register TColgp_HSequenceOfDir2d in _TColgp:
_TColgp.TColgp_HSequenceOfDir2d_swigregister(TColgp_HSequenceOfDir2d)

class TColgp_HSequenceOfVec(TColgp_SequenceOfVec, 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):
        _TColgp.TColgp_HSequenceOfVec_swiginit(self, _TColgp.new_TColgp_HSequenceOfVec(*args))

    def Sequence(self) -> "TColgp_SequenceOfVec const &":
        return _TColgp.TColgp_HSequenceOfVec_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_HSequenceOfVec_Append(self, *args)

    def ChangeSequence(self) -> "TColgp_SequenceOfVec &":
        return _TColgp.TColgp_HSequenceOfVec_ChangeSequence(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HSequenceOfVec

# Register TColgp_HSequenceOfVec in _TColgp:
_TColgp.TColgp_HSequenceOfVec_swigregister(TColgp_HSequenceOfVec)

class TColgp_HSequenceOfDir(TColgp_SequenceOfDir, 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):
        _TColgp.TColgp_HSequenceOfDir_swiginit(self, _TColgp.new_TColgp_HSequenceOfDir(*args))

    def Sequence(self) -> "TColgp_SequenceOfDir const &":
        return _TColgp.TColgp_HSequenceOfDir_Sequence(self)

    def Append(self, *args) -> "void":
        return _TColgp.TColgp_HSequenceOfDir_Append(self, *args)

    def ChangeSequence(self) -> "TColgp_SequenceOfDir &":
        return _TColgp.TColgp_HSequenceOfDir_ChangeSequence(self)


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

    __swig_destroy__ = _TColgp.delete_TColgp_HSequenceOfDir

# Register TColgp_HSequenceOfDir in _TColgp:
_TColgp.TColgp_HSequenceOfDir_swigregister(TColgp_HSequenceOfDir)





