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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _MAT2d:
_MAT2d.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 _MAT2d.process_exception(error, method_name, class_name)

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

import OCC.Core.Standard
import OCC.Core.NCollection
import OCC.Core.GeomAbs
import OCC.Core.TColStd
import OCC.Core.TCollection
import OCC.Core.Geom2d
import OCC.Core.gp
import OCC.Core.TColgp
import OCC.Core.MAT
import OCC.Core.Bisector
import OCC.Core.math
import OCC.Core.Message
import OCC.Core.OSD
import OCC.Core.IntRes2d

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




def Handle_MAT2d_Circuit_Create() -> "opencascade::handle< MAT2d_Circuit >":
    return _MAT2d.Handle_MAT2d_Circuit_Create()

def Handle_MAT2d_Circuit_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MAT2d_Circuit >":
    return _MAT2d.Handle_MAT2d_Circuit_DownCast(t)

def Handle_MAT2d_Circuit_IsNull(t: "opencascade::handle< MAT2d_Circuit > const &") -> "bool":
    return _MAT2d.Handle_MAT2d_Circuit_IsNull(t)

def Handle_MAT2d_Connexion_Create() -> "opencascade::handle< MAT2d_Connexion >":
    return _MAT2d.Handle_MAT2d_Connexion_Create()

def Handle_MAT2d_Connexion_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MAT2d_Connexion >":
    return _MAT2d.Handle_MAT2d_Connexion_DownCast(t)

def Handle_MAT2d_Connexion_IsNull(t: "opencascade::handle< MAT2d_Connexion > const &") -> "bool":
    return _MAT2d.Handle_MAT2d_Connexion_IsNull(t)
class MAT2d_Array2OfConnexion(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):
        _MAT2d.MAT2d_Array2OfConnexion_swiginit(self, _MAT2d.new_MAT2d_Array2OfConnexion(*args))

    def Init(self, theValue: "opencascade::handle< MAT2d_Connexion > const &") -> "void":
        return _MAT2d.MAT2d_Array2OfConnexion_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_Size(self)

    def Length(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_Length(self)

    def NbRows(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_NbRows(self)

    def NbColumns(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_NbColumns(self)

    def RowLength(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_RowLength(self)

    def ColLength(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_ColLength(self)

    def LowerRow(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_LowerRow(self)

    def UpperRow(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_UpperRow(self)

    def LowerCol(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_LowerCol(self)

    def UpperCol(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_Array2OfConnexion_UpperCol(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _MAT2d.MAT2d_Array2OfConnexion_IsDeletable(self)

    def Assign(self, theOther: "MAT2d_Array2OfConnexion") -> "NCollection_Array2< opencascade::handle< MAT2d_Connexion > > &":
        return _MAT2d.MAT2d_Array2OfConnexion_Assign(self, theOther)

    def Move(self, theOther: "MAT2d_Array2OfConnexion") -> "NCollection_Array2< opencascade::handle< MAT2d_Connexion > > &":
        return _MAT2d.MAT2d_Array2OfConnexion_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array2< opencascade::handle< MAT2d_Connexion > > &":
        return _MAT2d.MAT2d_Array2OfConnexion_Set(self, *args)

    def Value(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "opencascade::handle< MAT2d_Connexion > const &":
        return _MAT2d.MAT2d_Array2OfConnexion_Value(self, theRow, theCol)

    def ChangeValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const") -> "opencascade::handle< MAT2d_Connexion > &":
        return _MAT2d.MAT2d_Array2OfConnexion_ChangeValue(self, theRow, theCol)

    def __call__(self, *args) -> "opencascade::handle< MAT2d_Connexion > &":
        return _MAT2d.MAT2d_Array2OfConnexion___call__(self, *args)

    def SetValue(self, theRow: "Standard_Integer const", theCol: "Standard_Integer const", theItem: "opencascade::handle< MAT2d_Connexion > const &") -> "void":
        return _MAT2d.MAT2d_Array2OfConnexion_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 _MAT2d.MAT2d_Array2OfConnexion_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _MAT2d.delete_MAT2d_Array2OfConnexion

# Register MAT2d_Array2OfConnexion in _MAT2d:
_MAT2d.MAT2d_Array2OfConnexion_swigregister(MAT2d_Array2OfConnexion)

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

    def begin(self) -> "NCollection_DataMap< MAT2d_BiInt,int,MAT2d_MapBiIntHasher >::iterator":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_begin(self)

    def end(self) -> "NCollection_DataMap< MAT2d_BiInt,int,MAT2d_MapBiIntHasher >::iterator":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< MAT2d_BiInt,int,MAT2d_MapBiIntHasher >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< MAT2d_BiInt,int,MAT2d_MapBiIntHasher >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfBiIntInteger_swiginit(self, _MAT2d.new_MAT2d_DataMapOfBiIntInteger(*args))

    def Exchange(self, theOther: "MAT2d_DataMapOfBiIntInteger") -> "void":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Exchange(self, theOther)

    def Assign(self, theOther: "MAT2d_DataMapOfBiIntInteger") -> "NCollection_DataMap< MAT2d_BiInt,Standard_Integer,MAT2d_MapBiIntHasher > &":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Assign(self, theOther)

    def Set(self, theOther: "MAT2d_DataMapOfBiIntInteger") -> "NCollection_DataMap< MAT2d_BiInt,Standard_Integer,MAT2d_MapBiIntHasher > &":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Set(self, theOther)

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

    def Bind(self, theKey: "MAT2d_BiInt", theItem: "int const &") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "MAT2d_BiInt", theItem: "int const &") -> "int *":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "MAT2d_BiInt") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_IsBound(self, theKey)

    def UnBind(self, theKey: "MAT2d_BiInt") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_UnBind(self, theKey)

    def Seek(self, theKey: "MAT2d_BiInt") -> "int const *":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "MAT2d_BiInt") -> "int *":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "MAT2d_BiInt") -> "int &":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_ChangeFind(self, theKey)

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

    def Clear(self, *args) -> "void":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfBiIntInteger

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Size(self)

# Register MAT2d_DataMapOfBiIntInteger in _MAT2d:
_MAT2d.MAT2d_DataMapOfBiIntInteger_swigregister(MAT2d_DataMapOfBiIntInteger)

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

    def begin(self) -> "NCollection_DataMap< MAT2d_BiInt,NCollection_Sequence< int >,MAT2d_MapBiIntHasher >::iterator":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_begin(self)

    def end(self) -> "NCollection_DataMap< MAT2d_BiInt,NCollection_Sequence< int >,MAT2d_MapBiIntHasher >::iterator":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< MAT2d_BiInt,NCollection_Sequence< int >,MAT2d_MapBiIntHasher >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< MAT2d_BiInt,NCollection_Sequence< int >,MAT2d_MapBiIntHasher >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_swiginit(self, _MAT2d.new_MAT2d_DataMapOfBiIntSequenceOfInteger(*args))

    def Exchange(self, theOther: "MAT2d_DataMapOfBiIntSequenceOfInteger") -> "void":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Exchange(self, theOther)

    def Assign(self, theOther: "MAT2d_DataMapOfBiIntSequenceOfInteger") -> "NCollection_DataMap< MAT2d_BiInt,TColStd_SequenceOfInteger,MAT2d_MapBiIntHasher > &":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Assign(self, theOther)

    def Set(self, theOther: "MAT2d_DataMapOfBiIntSequenceOfInteger") -> "NCollection_DataMap< MAT2d_BiInt,TColStd_SequenceOfInteger,MAT2d_MapBiIntHasher > &":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Set(self, theOther)

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

    def Bind(self, theKey: "MAT2d_BiInt", theItem: "TColStd_SequenceOfInteger") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "MAT2d_BiInt", theItem: "TColStd_SequenceOfInteger") -> "NCollection_Sequence< int > *":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "MAT2d_BiInt") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_IsBound(self, theKey)

    def UnBind(self, theKey: "MAT2d_BiInt") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_UnBind(self, theKey)

    def Seek(self, theKey: "MAT2d_BiInt") -> "NCollection_Sequence< int > const *":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "MAT2d_BiInt") -> "NCollection_Sequence< int > *":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "MAT2d_BiInt") -> "NCollection_Sequence< int > &":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args) -> "NCollection_Sequence< int > &":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfBiIntSequenceOfInteger

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Size(self)

# Register MAT2d_DataMapOfBiIntSequenceOfInteger in _MAT2d:
_MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_swigregister(MAT2d_DataMapOfBiIntSequenceOfInteger)

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

    def begin(self) -> "NCollection_DataMap< int,Bisector_Bisec,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_begin(self)

    def end(self) -> "NCollection_DataMap< int,Bisector_Bisec,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,Bisector_Bisec,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,Bisector_Bisec,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerBisec_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerBisec(*args))

    def Exchange(self, theOther: "MAT2d_DataMapOfIntegerBisec") -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Exchange(self, theOther)

    def Assign(self, theOther: "MAT2d_DataMapOfIntegerBisec") -> "NCollection_DataMap< Standard_Integer,Bisector_Bisec,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Assign(self, theOther)

    def Set(self, theOther: "MAT2d_DataMapOfIntegerBisec") -> "NCollection_DataMap< Standard_Integer,Bisector_Bisec,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "Bisector_Bisec") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "Bisector_Bisec") -> "Bisector_Bisec *":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "Bisector_Bisec const *":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "Bisector_Bisec *":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "Bisector_Bisec &":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_ChangeFind(self, theKey)

    def __call__(self, *args) -> "Bisector_Bisec &":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerBisec

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Size(self)

    def Keys(self) -> "PyObject *":
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Keys(self)

# Register MAT2d_DataMapOfIntegerBisec in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerBisec_swigregister(MAT2d_DataMapOfIntegerBisec)

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

    def begin(self) -> "NCollection_DataMap< int,opencascade::handle< MAT2d_Connexion >,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_begin(self)

    def end(self) -> "NCollection_DataMap< int,opencascade::handle< MAT2d_Connexion >,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,opencascade::handle< MAT2d_Connexion >,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,opencascade::handle< MAT2d_Connexion >,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerConnexion_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerConnexion(*args))

    def Exchange(self, theOther: "MAT2d_DataMapOfIntegerConnexion") -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Exchange(self, theOther)

    def Assign(self, theOther: "MAT2d_DataMapOfIntegerConnexion") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< MAT2d_Connexion >,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Assign(self, theOther)

    def Set(self, theOther: "MAT2d_DataMapOfIntegerConnexion") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< MAT2d_Connexion >,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "opencascade::handle< MAT2d_Connexion > const &") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "opencascade::handle< MAT2d_Connexion > const &") -> "opencascade::handle< MAT2d_Connexion > *":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "opencascade::handle< MAT2d_Connexion > const *":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "opencascade::handle< MAT2d_Connexion > *":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "opencascade::handle< MAT2d_Connexion > &":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_ChangeFind(self, theKey)

    def __call__(self, *args) -> "opencascade::handle< MAT2d_Connexion > &":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerConnexion

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Size(self)

    def Keys(self) -> "PyObject *":
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Keys(self)

# Register MAT2d_DataMapOfIntegerConnexion in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerConnexion_swigregister(MAT2d_DataMapOfIntegerConnexion)

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

    def begin(self) -> "NCollection_DataMap< int,gp_Pnt2d,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_begin(self)

    def end(self) -> "NCollection_DataMap< int,gp_Pnt2d,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,gp_Pnt2d,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,gp_Pnt2d,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerPnt2d_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerPnt2d(*args))

    def Exchange(self, theOther: "MAT2d_DataMapOfIntegerPnt2d") -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Exchange(self, theOther)

    def Assign(self, theOther: "MAT2d_DataMapOfIntegerPnt2d") -> "NCollection_DataMap< Standard_Integer,gp_Pnt2d,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Assign(self, theOther)

    def Set(self, theOther: "MAT2d_DataMapOfIntegerPnt2d") -> "NCollection_DataMap< Standard_Integer,gp_Pnt2d,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "gp_Pnt2d") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "gp_Pnt2d") -> "gp_Pnt2d *":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "gp_Pnt2d const *":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "gp_Pnt2d *":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "gp_Pnt2d &":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_ChangeFind(self, theKey)

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

    def Clear(self, *args) -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerPnt2d

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Size(self)

    def Keys(self) -> "PyObject *":
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Keys(self)

# Register MAT2d_DataMapOfIntegerPnt2d in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerPnt2d_swigregister(MAT2d_DataMapOfIntegerPnt2d)

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

    def begin(self) -> "NCollection_DataMap< int,MAT2d_SequenceOfConnexion,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_begin(self)

    def end(self) -> "NCollection_DataMap< int,MAT2d_SequenceOfConnexion,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,MAT2d_SequenceOfConnexion,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,MAT2d_SequenceOfConnexion,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerSequenceOfConnexion(*args))

    def Exchange(self, theOther: "NCollection_DataMap< Standard_Integer,MAT2d_SequenceOfConnexion,TColStd_MapIntegerHasher > &") -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Exchange(self, theOther)

    def Assign(self, theOther: "NCollection_DataMap< Standard_Integer,MAT2d_SequenceOfConnexion,TColStd_MapIntegerHasher > const &") -> "NCollection_DataMap< Standard_Integer,MAT2d_SequenceOfConnexion,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Assign(self, theOther)

    def Set(self, theOther: "NCollection_DataMap< Standard_Integer,MAT2d_SequenceOfConnexion,TColStd_MapIntegerHasher > const &") -> "NCollection_DataMap< Standard_Integer,MAT2d_SequenceOfConnexion,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "MAT2d_SequenceOfConnexion") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "MAT2d_SequenceOfConnexion") -> "MAT2d_SequenceOfConnexion *":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "MAT2d_SequenceOfConnexion const *":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "MAT2d_SequenceOfConnexion *":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "MAT2d_SequenceOfConnexion &":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_ChangeFind(self, theKey)

    def __call__(self, *args) -> "MAT2d_SequenceOfConnexion &":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerSequenceOfConnexion

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Size(self)

    def Keys(self) -> "PyObject *":
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Keys(self)

# Register MAT2d_DataMapOfIntegerSequenceOfConnexion in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_swigregister(MAT2d_DataMapOfIntegerSequenceOfConnexion)

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

    def begin(self) -> "NCollection_DataMap< int,gp_Vec2d,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_begin(self)

    def end(self) -> "NCollection_DataMap< int,gp_Vec2d,NCollection_DefaultHasher< int > >::iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,gp_Vec2d,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,gp_Vec2d,NCollection_DefaultHasher< int > >::const_iterator":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerVec2d_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerVec2d(*args))

    def Exchange(self, theOther: "MAT2d_DataMapOfIntegerVec2d") -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Exchange(self, theOther)

    def Assign(self, theOther: "MAT2d_DataMapOfIntegerVec2d") -> "NCollection_DataMap< Standard_Integer,gp_Vec2d,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Assign(self, theOther)

    def Set(self, theOther: "MAT2d_DataMapOfIntegerVec2d") -> "NCollection_DataMap< Standard_Integer,gp_Vec2d,TColStd_MapIntegerHasher > &":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "gp_Vec2d") -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "gp_Vec2d") -> "gp_Vec2d *":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "gp_Vec2d const *":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "gp_Vec2d *":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "gp_Vec2d &":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_ChangeFind(self, theKey)

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

    def Clear(self, *args) -> "void":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerVec2d

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Size(self)

    def Keys(self) -> "PyObject *":
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Keys(self)

# Register MAT2d_DataMapOfIntegerVec2d in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerVec2d_swigregister(MAT2d_DataMapOfIntegerVec2d)

class MAT2d_SequenceOfConnexion(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< MAT2d_Connexion > >::iterator":
        return _MAT2d.MAT2d_SequenceOfConnexion_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< MAT2d_Connexion > >::iterator":
        return _MAT2d.MAT2d_SequenceOfConnexion_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< MAT2d_Connexion > >::const_iterator":
        return _MAT2d.MAT2d_SequenceOfConnexion_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< MAT2d_Connexion > >::const_iterator":
        return _MAT2d.MAT2d_SequenceOfConnexion_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_SequenceOfConnexion_swiginit(self, _MAT2d.new_MAT2d_SequenceOfConnexion(*args))

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfConnexion_Size(self)

    def Length(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfConnexion_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfConnexion_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfConnexion_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _MAT2d.MAT2d_SequenceOfConnexion_IsEmpty(self)

    def Reverse(self) -> "void":
        return _MAT2d.MAT2d_SequenceOfConnexion_Reverse(self)

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

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

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

    def Assign(self, theOther: "MAT2d_SequenceOfConnexion") -> "NCollection_Sequence< opencascade::handle< MAT2d_Connexion > > &":
        return _MAT2d.MAT2d_SequenceOfConnexion_Assign(self, theOther)

    def Set(self, theOther: "MAT2d_SequenceOfConnexion") -> "NCollection_Sequence< opencascade::handle< MAT2d_Connexion > > &":
        return _MAT2d.MAT2d_SequenceOfConnexion_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfConnexion_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfConnexion_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfConnexion_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfConnexion_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfConnexion_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "MAT2d_SequenceOfConnexion") -> "void":
        return _MAT2d.MAT2d_SequenceOfConnexion_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< MAT2d_Connexion > const &":
        return _MAT2d.MAT2d_SequenceOfConnexion_First(self)

    def ChangeFirst(self) -> "opencascade::handle< MAT2d_Connexion > &":
        return _MAT2d.MAT2d_SequenceOfConnexion_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< MAT2d_Connexion > const &":
        return _MAT2d.MAT2d_SequenceOfConnexion_Last(self)

    def ChangeLast(self) -> "opencascade::handle< MAT2d_Connexion > &":
        return _MAT2d.MAT2d_SequenceOfConnexion_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< MAT2d_Connexion > const &":
        return _MAT2d.MAT2d_SequenceOfConnexion_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< MAT2d_Connexion > &":
        return _MAT2d.MAT2d_SequenceOfConnexion_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< MAT2d_Connexion > &":
        return _MAT2d.MAT2d_SequenceOfConnexion___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< MAT2d_Connexion > const &") -> "void":
        return _MAT2d.MAT2d_SequenceOfConnexion_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _MAT2d.delete_MAT2d_SequenceOfConnexion

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


# Register MAT2d_SequenceOfConnexion in _MAT2d:
_MAT2d.MAT2d_SequenceOfConnexion_swigregister(MAT2d_SequenceOfConnexion)

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

class MAT2d_SequenceOfSequenceOfCurve(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< TColGeom2d_SequenceOfCurve >::iterator":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_begin(self)

    def end(self) -> "NCollection_Sequence< TColGeom2d_SequenceOfCurve >::iterator":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_end(self)

    def cbegin(self) -> "NCollection_Sequence< TColGeom2d_SequenceOfCurve >::const_iterator":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_cbegin(self)

    def cend(self) -> "NCollection_Sequence< TColGeom2d_SequenceOfCurve >::const_iterator":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_SequenceOfSequenceOfCurve_swiginit(self, _MAT2d.new_MAT2d_SequenceOfSequenceOfCurve(*args))

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Size(self)

    def Length(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_IsEmpty(self)

    def Reverse(self) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Reverse(self)

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

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

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

    def Assign(self, theOther: "MAT2d_SequenceOfSequenceOfCurve") -> "NCollection_Sequence< TColGeom2d_SequenceOfCurve > &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Assign(self, theOther)

    def Set(self, theOther: "MAT2d_SequenceOfSequenceOfCurve") -> "NCollection_Sequence< TColGeom2d_SequenceOfCurve > &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "MAT2d_SequenceOfSequenceOfCurve") -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Split(self, theIndex, theSeq)

    def First(self) -> "TColGeom2d_SequenceOfCurve const &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_First(self)

    def ChangeFirst(self) -> "TColGeom2d_SequenceOfCurve &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_ChangeFirst(self)

    def Last(self) -> "TColGeom2d_SequenceOfCurve const &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Last(self)

    def ChangeLast(self) -> "TColGeom2d_SequenceOfCurve &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "TColGeom2d_SequenceOfCurve const &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "TColGeom2d_SequenceOfCurve &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "TColGeom2d_SequenceOfCurve &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "TColGeom2d_SequenceOfCurve const &") -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _MAT2d.delete_MAT2d_SequenceOfSequenceOfCurve

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


# Register MAT2d_SequenceOfSequenceOfCurve in _MAT2d:
_MAT2d.MAT2d_SequenceOfSequenceOfCurve_swigregister(MAT2d_SequenceOfSequenceOfCurve)

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

class MAT2d_SequenceOfSequenceOfGeometry(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< TColGeom2d_SequenceOfGeometry >::iterator":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_begin(self)

    def end(self) -> "NCollection_Sequence< TColGeom2d_SequenceOfGeometry >::iterator":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_end(self)

    def cbegin(self) -> "NCollection_Sequence< TColGeom2d_SequenceOfGeometry >::const_iterator":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_cbegin(self)

    def cend(self) -> "NCollection_Sequence< TColGeom2d_SequenceOfGeometry >::const_iterator":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_swiginit(self, _MAT2d.new_MAT2d_SequenceOfSequenceOfGeometry(*args))

    def Size(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Size(self)

    def Length(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_IsEmpty(self)

    def Reverse(self) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Reverse(self)

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

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

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

    def Assign(self, theOther: "MAT2d_SequenceOfSequenceOfGeometry") -> "NCollection_Sequence< TColGeom2d_SequenceOfGeometry > &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Assign(self, theOther)

    def Set(self, theOther: "MAT2d_SequenceOfSequenceOfGeometry") -> "NCollection_Sequence< TColGeom2d_SequenceOfGeometry > &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "MAT2d_SequenceOfSequenceOfGeometry") -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Split(self, theIndex, theSeq)

    def First(self) -> "TColGeom2d_SequenceOfGeometry const &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_First(self)

    def ChangeFirst(self) -> "TColGeom2d_SequenceOfGeometry &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_ChangeFirst(self)

    def Last(self) -> "TColGeom2d_SequenceOfGeometry const &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Last(self)

    def ChangeLast(self) -> "TColGeom2d_SequenceOfGeometry &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "TColGeom2d_SequenceOfGeometry const &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "TColGeom2d_SequenceOfGeometry &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "TColGeom2d_SequenceOfGeometry &":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "TColGeom2d_SequenceOfGeometry const &") -> "void":
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _MAT2d.delete_MAT2d_SequenceOfSequenceOfGeometry

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


# Register MAT2d_SequenceOfSequenceOfGeometry in _MAT2d:
_MAT2d.MAT2d_SequenceOfSequenceOfGeometry_swigregister(MAT2d_SequenceOfSequenceOfGeometry)

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

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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        I1: int
        I2: int

        Returns
        -------
        None

        """
        _MAT2d.MAT2d_BiInt_swiginit(self, _MAT2d.new_MAT2d_BiInt(*args))

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

        Returns
        -------
        int
        No available documentation.

        Parameters
        ----------
        I1: int

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_BiInt_FirstIndex(self, *args)

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

        Parameters
        ----------
        B: MAT2d_BiInt

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_BiInt_IsEqual(self, *args)

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

        Returns
        -------
        int
        No available documentation.

        Parameters
        ----------
        I2: int

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_BiInt_SecondIndex(self, *args)

    def __eq_wrapper__(self, other: "MAT2d_BiInt") -> "bool":
        return _MAT2d.MAT2d_BiInt___eq_wrapper__(self, other)

    def __eq__(self, right):
        try:
            return self.__eq_wrapper__(right)
        except:
            return False


    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_BiInt

# Register MAT2d_BiInt in _MAT2d:
_MAT2d.MAT2d_BiInt_swigregister(MAT2d_BiInt)

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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        aJoinType: GeomAbs_JoinType,optional
        	default value is GeomAbs_Arc
        IsOpenResult: bool,optional
        	default value is Standard_False

        Returns
        -------
        None

        """
        _MAT2d.MAT2d_Circuit_swiginit(self, _MAT2d.new_MAT2d_Circuit(*args))

    def Connexion(self, *args) -> "opencascade::handle< MAT2d_Connexion >":
        r"""
        Returns the connexion on the item <index> in me.

        Parameters
        ----------
        Index: int

        Returns
        -------
        opencascade::handle<MAT2d_Connexion>

        """
        return _MAT2d.MAT2d_Circuit_Connexion(self, *args)

    def ConnexionOn(self, *args) -> "Standard_Boolean":
        r"""
        Returns <true> is there is a connexion on the item <index> in <self>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_Circuit_ConnexionOn(self, *args)

    def LineLength(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of items on the line <indexline>.

        Parameters
        ----------
        IndexLine: int

        Returns
        -------
        int

        """
        return _MAT2d.MAT2d_Circuit_LineLength(self, *args)

    def NumberOfItems(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of items .

        Returns
        -------
        int

        """
        return _MAT2d.MAT2d_Circuit_NumberOfItems(self, *args)

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

        Parameters
        ----------
        aFigure: MAT2d_SequenceOfSequenceOfGeometry
        IsClosed: TColStd_SequenceOfBoolean
        IndRefLine: int
        Trigo: bool

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Circuit_Perform(self, *args)

    def RefToEqui(self, *args) -> "TColStd_SequenceOfInteger const &":
        r"""
        Returns the set of index of the items in <self>corresponding to the curve <indcurve> on the line <indline> from the initial figure.

        Parameters
        ----------
        IndLine: int
        IndCurve: int

        Returns
        -------
        TColStd_SequenceOfInteger

        """
        return _MAT2d.MAT2d_Circuit_RefToEqui(self, *args)

    def Value(self, *args) -> "opencascade::handle< Geom2d_Geometry >":
        r"""
        Returns the item at position <index> in <self>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        opencascade::handle<Geom2d_Geometry>

        """
        return _MAT2d.MAT2d_Circuit_Value(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_Circuit

# Register MAT2d_Circuit in _MAT2d:
_MAT2d.MAT2d_Circuit_swigregister(MAT2d_Circuit)

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

    def __init__(self, *args):
        r"""
        No available documentation.

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        LineA: int
        LineB: int
        ItemA: int
        ItemB: int
        Distance: float
        ParameterOnA: float
        ParameterOnB: float
        PointA: gp_Pnt2d
        PointB: gp_Pnt2d

        Returns
        -------
        None

        """
        _MAT2d.MAT2d_Connexion_swiginit(self, _MAT2d.new_MAT2d_Connexion(*args))

    def Distance(self, *args) -> "void":
        r"""
        Returns the distance between the two points.

        Returns
        -------
        float
        No available documentation.

        Parameters
        ----------
        aDistance: float

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_Distance(self, *args)

    def Dump(self, *args) -> "void":
        r"""
        Print <self>.

        Parameters
        ----------
        Deep: int,optional
        	default value is 0
        Offset: int,optional
        	default value is 0

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_Dump(self, *args)

    def IndexFirstLine(self, *args) -> "void":
        r"""
        Returns the index on the first line.

        Returns
        -------
        int
        No available documentation.

        Parameters
        ----------
        anIndex: int

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_IndexFirstLine(self, *args)

    def IndexItemOnFirst(self, *args) -> "void":
        r"""
        Returns the index of the item on the first line.

        Returns
        -------
        int
        No available documentation.

        Parameters
        ----------
        anIndex: int

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_IndexItemOnFirst(self, *args)

    def IndexItemOnSecond(self, *args) -> "void":
        r"""
        Returns the index of the item on the second line.

        Returns
        -------
        int
        No available documentation.

        Parameters
        ----------
        anIndex: int

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_IndexItemOnSecond(self, *args)

    def IndexSecondLine(self, *args) -> "void":
        r"""
        Returns the index on the second line.

        Returns
        -------
        int
        No available documentation.

        Parameters
        ----------
        anIndex: int

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_IndexSecondLine(self, *args)

    def IsAfter(self, *args) -> "Standard_Boolean":
        r"""
        Returns <true> if my firstpoint is on the same line than the firstpoint of <aconnexion> and my firstpoint is after the firstpoint of <aconnexion> on the line. <asense> = 1 if <aconnexion> is on the left of its firstline, else <asense> = -1.

        Parameters
        ----------
        aConnexion: MAT2d_Connexion
        aSense: float

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_Connexion_IsAfter(self, *args)

    def ParameterOnFirst(self, *args) -> "void":
        r"""
        Returns the parameter of the point on the firstline.

        Returns
        -------
        float
        No available documentation.

        Parameters
        ----------
        aParameter: float

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_ParameterOnFirst(self, *args)

    def ParameterOnSecond(self, *args) -> "void":
        r"""
        Returns the parameter of the point on the secondline.

        Returns
        -------
        float
        No available documentation.

        Parameters
        ----------
        aParameter: float

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_ParameterOnSecond(self, *args)

    def PointOnFirst(self, *args) -> "void":
        r"""
        Returns the point on the firstline.

        Returns
        -------
        gp_Pnt2d
        No available documentation.

        Parameters
        ----------
        aPoint: gp_Pnt2d

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_PointOnFirst(self, *args)

    def PointOnSecond(self, *args) -> "void":
        r"""
        Returns the point on the secondline.

        Returns
        -------
        gp_Pnt2d
        No available documentation.

        Parameters
        ----------
        aPoint: gp_Pnt2d

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Connexion_PointOnSecond(self, *args)

    def Reverse(self, *args) -> "opencascade::handle< MAT2d_Connexion >":
        r"""
        Returns the reverse connexion of <self>. the firstpoint is the secondpoint. the secondpoint is the firstpoint.

        Returns
        -------
        opencascade::handle<MAT2d_Connexion>

        """
        return _MAT2d.MAT2d_Connexion_Reverse(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_Connexion

# Register MAT2d_Connexion in _MAT2d:
_MAT2d.MAT2d_Connexion_swigregister(MAT2d_Connexion)

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

    @staticmethod
    def HashCode(*args) -> "Standard_Integer":
        r"""
        Computes a hash code for the given key, in the range [1, theupperbound] @param thekey the key which hash code is to be computed @param theupperbound the upper bound of the range a computing hash code must be within returns a computed hash code, in the range [1, theupperbound].

        Parameters
        ----------
        theKey: MAT2d_BiInt
        theUpperBound: int

        Returns
        -------
        int

        """
        return _MAT2d.MAT2d_MapBiIntHasher_HashCode(*args)

    @staticmethod
    def IsEqual(*args) -> "Standard_Boolean":
        r"""
        No available documentation.

        Parameters
        ----------
        Key1: MAT2d_BiInt
        Key2: MAT2d_BiInt

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_MapBiIntHasher_IsEqual(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _MAT2d.MAT2d_MapBiIntHasher_swiginit(self, _MAT2d.new_MAT2d_MapBiIntHasher())
    __swig_destroy__ = _MAT2d.delete_MAT2d_MapBiIntHasher

# Register MAT2d_MapBiIntHasher in _MAT2d:
_MAT2d.MAT2d_MapBiIntHasher_swigregister(MAT2d_MapBiIntHasher)

def MAT2d_MapBiIntHasher_HashCode(*args) -> "Standard_Integer":
    r"""
    Computes a hash code for the given key, in the range [1, theupperbound] @param thekey the key which hash code is to be computed @param theupperbound the upper bound of the range a computing hash code must be within returns a computed hash code, in the range [1, theupperbound].

    Parameters
    ----------
    theKey: MAT2d_BiInt
    theUpperBound: int

    Returns
    -------
    int

    """
    return _MAT2d.MAT2d_MapBiIntHasher_HashCode(*args)

def MAT2d_MapBiIntHasher_IsEqual(*args) -> "Standard_Boolean":
    r"""
    No available documentation.

    Parameters
    ----------
    Key1: MAT2d_BiInt
    Key2: MAT2d_BiInt

    Returns
    -------
    bool

    """
    return _MAT2d.MAT2d_MapBiIntHasher_IsEqual(*args)

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

    def __init__(self, *args):
        r"""
        Empty construtor.

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

        Returns
        -------
        None

        """
        _MAT2d.MAT2d_Mat2d_swiginit(self, _MAT2d.new_MAT2d_Mat2d(*args))

    def bisector(self, *args) -> "opencascade::handle< MAT_Bisector >":
        r"""
        Returns the current root.

        Returns
        -------
        opencascade::handle<MAT_Bisector>

        """
        return _MAT2d.MAT2d_Mat2d_bisector(self, *args)

    def CreateMat(self, *args) -> "void":
        r"""
        Algoritm of computation of the bisecting locus.

        Parameters
        ----------
        aTool: MAT2d_Tool2d

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Mat2d_CreateMat(self, *args)

    def CreateMatOpen(self, *args) -> "void":
        r"""
        Algoritm of computation of the bisecting locus for open wire.

        Parameters
        ----------
        aTool: MAT2d_Tool2d

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Mat2d_CreateMatOpen(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Initialize an iterator on the set of the roots of the trees of bisectors.

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Mat2d_Init(self, *args)

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        Returns <true> if createmat has succeeded.

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_Mat2d_IsDone(self, *args)

    def More(self, *args) -> "Standard_Boolean":
        r"""
        Return false if there is no more roots.

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_Mat2d_More(self, *args)

    def Next(self, *args) -> "void":
        r"""
        Move to the next root.

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Mat2d_Next(self, *args)

    def NumberOfBisectors(self, *args) -> "Standard_Integer":
        r"""
        Returns the total number of bisectors.

        Returns
        -------
        int

        """
        return _MAT2d.MAT2d_Mat2d_NumberOfBisectors(self, *args)

    def SemiInfinite(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if there are semi_infinite bisectors. so there is a tree for each semi_infinte bisector.

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_Mat2d_SemiInfinite(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_Mat2d

# Register MAT2d_Mat2d in _MAT2d:
_MAT2d.MAT2d_Mat2d_swigregister(MAT2d_Mat2d)

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

    def __init__(self, *args):
        r"""
        No available documentation.

        Returns
        -------
        None

        """
        _MAT2d.MAT2d_MiniPath_swiginit(self, _MAT2d.new_MAT2d_MiniPath(*args))

    def ConnexionsFrom(self, *args) -> "MAT2d_SequenceOfConnexion &":
        r"""
        Returns the connexions which start on line designed by <index>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        MAT2d_SequenceOfConnexion

        """
        return _MAT2d.MAT2d_MiniPath_ConnexionsFrom(self, *args)

    def Father(self, *args) -> "opencascade::handle< MAT2d_Connexion >":
        r"""
        Returns the connexion which ends on line designed by <index>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        opencascade::handle<MAT2d_Connexion>

        """
        return _MAT2d.MAT2d_MiniPath_Father(self, *args)

    def IsConnexionsFrom(self, *args) -> "Standard_Boolean":
        r"""
        Returns <true> if there is one connexion which starts on line designed by <index>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_MiniPath_IsConnexionsFrom(self, *args)

    def IsRoot(self, *args) -> "Standard_Boolean":
        r"""
        Returns <true> if the line designed by <index> is the root.

        Parameters
        ----------
        Index: int

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_MiniPath_IsRoot(self, *args)

    def Path(self, *args) -> "MAT2d_SequenceOfConnexion const &":
        r"""
        Returns the sequence of connexions corresponding to the path.

        Returns
        -------
        MAT2d_SequenceOfConnexion

        """
        return _MAT2d.MAT2d_MiniPath_Path(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Computes the path to link the lines in <figure>. the path starts on the line of index <indstart> <sense> = true if the circuit turns in the trigonometric sense.

        Parameters
        ----------
        Figure: MAT2d_SequenceOfSequenceOfGeometry
        IndStart: int
        Sense: bool

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_MiniPath_Perform(self, *args)

    def RunOnConnexions(self, *args) -> "void":
        r"""
        Run on the set of connexions to compute the path. the path is an exploration of the tree which contains the connexions and their reverses. if the tree of connexions is a / | b e / | | c d f //! the path is a->b, b->c, c->b, b->d, d->b, b->a, a->e, e->f, f->e, e->a.

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_MiniPath_RunOnConnexions(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_MiniPath

# Register MAT2d_MiniPath in _MAT2d:
_MAT2d.MAT2d_MiniPath_swigregister(MAT2d_MiniPath)

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

    def __init__(self, *args):
        r"""
        Empty constructor.

        Returns
        -------
        None

        """
        _MAT2d.MAT2d_Tool2d_swiginit(self, _MAT2d.new_MAT2d_Tool2d(*args))

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

        Parameters
        ----------
        Index1: int
        Index2: int

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Tool2d_BisecFusion(self, *args)

    def ChangeGeomBis(self, *args) -> "Bisector_Bisec &":
        r"""
        Returns the <bisec> of index <index> in <thegeombisectors>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        Bisector_Bisec

        """
        return _MAT2d.MAT2d_Tool2d_ChangeGeomBis(self, *args)

    def Circuit(self, *args) -> "opencascade::handle< MAT2d_Circuit >":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<MAT2d_Circuit>

        """
        return _MAT2d.MAT2d_Tool2d_Circuit(self, *args)

    def CreateBisector(self, *args) -> "void":
        r"""
        Creates the geometric bisector defined by <abisector>.

        Parameters
        ----------
        abisector: MAT_Bisector

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Tool2d_CreateBisector(self, *args)

    def Distance(self, *args) -> "Standard_Real":
        r"""
        Returns the distance between the two points designed by their parameters on <abisector>.

        Parameters
        ----------
        abisector: MAT_Bisector
        param1: float
        param2: float

        Returns
        -------
        float

        """
        return _MAT2d.MAT2d_Tool2d_Distance(self, *args)

    def Dump(self, *args) -> "void":
        r"""
        Displays informations about the bisector defined by <bisector>.

        Parameters
        ----------
        bisector: int
        erease: int

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Tool2d_Dump(self, *args)

    def FirstPoint(self, *args) -> "Standard_Integer":
        r"""
        Creates the point at the origin of the bisector between anitem and the previous item. dist is the distance from the firstpoint to <anitem>. returns the index of this point in <thegeompnts>.

        Parameters
        ----------
        anitem: int

        Returns
        -------
        dist: float

        """
        return _MAT2d.MAT2d_Tool2d_FirstPoint(self, *args)

    def GeomBis(self, *args) -> "Bisector_Bisec const &":
        r"""
        Returns the <bisec> of index <index> in <thegeombisectors>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        Bisector_Bisec

        """
        return _MAT2d.MAT2d_Tool2d_GeomBis(self, *args)

    def GeomElt(self, *args) -> "opencascade::handle< Geom2d_Geometry >":
        r"""
        Returns the geometry of index <index> in <thegeomelts>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        opencascade::handle<Geom2d_Geometry>

        """
        return _MAT2d.MAT2d_Tool2d_GeomElt(self, *args)

    def GeomPnt(self, *args) -> "gp_Pnt2d const":
        r"""
        Returns the point of index <index> in the <thegeompnts>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        gp_Pnt2d

        """
        return _MAT2d.MAT2d_Tool2d_GeomPnt(self, *args)

    def GeomVec(self, *args) -> "gp_Vec2d const":
        r"""
        Returns the vector of index <index> in the <thegeomvecs>.

        Parameters
        ----------
        Index: int

        Returns
        -------
        gp_Vec2d

        """
        return _MAT2d.MAT2d_Tool2d_GeomVec(self, *args)

    def InitItems(self, *args) -> "void":
        r"""
        Inititems cuts the line in items. this items are the geometrics representations of the basicelts from mat.

        Parameters
        ----------
        aCircuit: MAT2d_Circuit

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Tool2d_InitItems(self, *args)

    def IntersectBisector(self, *args) -> "Standard_Real":
        r"""
        Computes the point of intersection between the bisectors defined by <bisectorone> and <bisectortwo> . if this point exists, <intpnt> is its index in <thegeompnts> and return the distance of the point from the bisector else return <reallast>.

        Parameters
        ----------
        bisectorone: MAT_Bisector
        bisectortwo: MAT_Bisector

        Returns
        -------
        intpnt: int

        """
        return _MAT2d.MAT2d_Tool2d_IntersectBisector(self, *args)

    def NumberOfItems(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of items .

        Returns
        -------
        int

        """
        return _MAT2d.MAT2d_Tool2d_NumberOfItems(self, *args)

    def Sense(self, *args) -> "void":
        r"""
        <aside> defines the side of the computation of the map.

        Parameters
        ----------
        aside: MAT_Side

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Tool2d_Sense(self, *args)

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

        Parameters
        ----------
        aJoinType: GeomAbs_JoinType

        Returns
        -------
        None

        """
        return _MAT2d.MAT2d_Tool2d_SetJoinType(self, *args)

    def Tangent(self, *args) -> "Standard_Integer":
        r"""
        Creates the tangent at the end of the bisector defined by <bisector>. returns the index of this vector in <thegeomvecs>.

        Parameters
        ----------
        bisector: int

        Returns
        -------
        int

        """
        return _MAT2d.MAT2d_Tool2d_Tangent(self, *args)

    def TangentAfter(self, *args) -> "Standard_Integer":
        r"""
        Creates the reversed tangent at the origin of the item defined by <anitem>. returns the index of this vector in <thegeomvecs>.

        Parameters
        ----------
        anitem: int
        IsOpenResult: bool

        Returns
        -------
        int

        """
        return _MAT2d.MAT2d_Tool2d_TangentAfter(self, *args)

    def TangentBefore(self, *args) -> "Standard_Integer":
        r"""
        Creates the tangent at the end of the item defined by <anitem>. returns the index of this vector in <thegeomvecs>.

        Parameters
        ----------
        anitem: int
        IsOpenResult: bool

        Returns
        -------
        int

        """
        return _MAT2d.MAT2d_Tool2d_TangentBefore(self, *args)

    def ToleranceOfConfusion(self, *args) -> "Standard_Real":
        r"""
        Returns tolerance to test the confusion of two points.

        Returns
        -------
        float

        """
        return _MAT2d.MAT2d_Tool2d_ToleranceOfConfusion(self, *args)

    def TrimBisector(self, *args) -> "Standard_Boolean":
        r"""
        Trims the geometric bisector by the <firstparameter> of <abisector>. if the parameter is out of the bisector, return false. else return true.

        Parameters
        ----------
        abisector: MAT_Bisector

        Returns
        -------
        bool
        Trims the geometric bisector by the point of index <apoint> in <thegeompnts>. if the point is out of the bisector, return false. else return true.

        Parameters
        ----------
        abisector: MAT_Bisector
        apoint: int

        Returns
        -------
        bool

        """
        return _MAT2d.MAT2d_Tool2d_TrimBisector(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_Tool2d

# Register MAT2d_Tool2d in _MAT2d:
_MAT2d.MAT2d_Tool2d_swigregister(MAT2d_Tool2d)


@classnotwrapped
class MAT2d_SketchExplorer:
	pass

@classnotwrapped
class MAT2d_CutCurve:
	pass






