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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _ShapeFix:
_ShapeFix.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 _ShapeFix.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.TopoDS
import OCC.Core.Message
import OCC.Core.TCollection
import OCC.Core.OSD
import OCC.Core.TColStd
import OCC.Core.TopAbs
import OCC.Core.TopLoc
import OCC.Core.gp
import OCC.Core.ShapeBuild
import OCC.Core.Geom
import OCC.Core.GeomAbs
import OCC.Core.TColgp
import OCC.Core.Geom2d
import OCC.Core.BRepTools
import OCC.Core.Bnd
import OCC.Core.BVH
import OCC.Core.TopTools
import OCC.Core.BRep
import OCC.Core.Poly
import OCC.Core.TShort
import OCC.Core.ShapeExtend
import OCC.Core.TColGeom
import OCC.Core.ShapeAnalysis
import OCC.Core.Adaptor3d
import OCC.Core.Adaptor2d
import OCC.Core.math
import OCC.Core.GeomAdaptor
import OCC.Core.IntRes2d
import OCC.Core.ShapeConstruct
import OCC.Core.BRepBuilderAPI

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




def Handle_ShapeFix_Edge_Create() -> "opencascade::handle< ShapeFix_Edge >":
    return _ShapeFix.Handle_ShapeFix_Edge_Create()

def Handle_ShapeFix_Edge_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_Edge >":
    return _ShapeFix.Handle_ShapeFix_Edge_DownCast(t)

def Handle_ShapeFix_Edge_IsNull(t: "opencascade::handle< ShapeFix_Edge > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_Edge_IsNull(t)

def Handle_ShapeFix_EdgeProjAux_Create() -> "opencascade::handle< ShapeFix_EdgeProjAux >":
    return _ShapeFix.Handle_ShapeFix_EdgeProjAux_Create()

def Handle_ShapeFix_EdgeProjAux_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_EdgeProjAux >":
    return _ShapeFix.Handle_ShapeFix_EdgeProjAux_DownCast(t)

def Handle_ShapeFix_EdgeProjAux_IsNull(t: "opencascade::handle< ShapeFix_EdgeProjAux > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_EdgeProjAux_IsNull(t)

def Handle_ShapeFix_Root_Create() -> "opencascade::handle< ShapeFix_Root >":
    return _ShapeFix.Handle_ShapeFix_Root_Create()

def Handle_ShapeFix_Root_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_Root >":
    return _ShapeFix.Handle_ShapeFix_Root_DownCast(t)

def Handle_ShapeFix_Root_IsNull(t: "opencascade::handle< ShapeFix_Root > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_Root_IsNull(t)

def Handle_ShapeFix_ComposeShell_Create() -> "opencascade::handle< ShapeFix_ComposeShell >":
    return _ShapeFix.Handle_ShapeFix_ComposeShell_Create()

def Handle_ShapeFix_ComposeShell_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_ComposeShell >":
    return _ShapeFix.Handle_ShapeFix_ComposeShell_DownCast(t)

def Handle_ShapeFix_ComposeShell_IsNull(t: "opencascade::handle< ShapeFix_ComposeShell > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_ComposeShell_IsNull(t)

def Handle_ShapeFix_Face_Create() -> "opencascade::handle< ShapeFix_Face >":
    return _ShapeFix.Handle_ShapeFix_Face_Create()

def Handle_ShapeFix_Face_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_Face >":
    return _ShapeFix.Handle_ShapeFix_Face_DownCast(t)

def Handle_ShapeFix_Face_IsNull(t: "opencascade::handle< ShapeFix_Face > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_Face_IsNull(t)

def Handle_ShapeFix_FixSmallFace_Create() -> "opencascade::handle< ShapeFix_FixSmallFace >":
    return _ShapeFix.Handle_ShapeFix_FixSmallFace_Create()

def Handle_ShapeFix_FixSmallFace_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_FixSmallFace >":
    return _ShapeFix.Handle_ShapeFix_FixSmallFace_DownCast(t)

def Handle_ShapeFix_FixSmallFace_IsNull(t: "opencascade::handle< ShapeFix_FixSmallFace > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_FixSmallFace_IsNull(t)

def Handle_ShapeFix_FixSmallSolid_Create() -> "opencascade::handle< ShapeFix_FixSmallSolid >":
    return _ShapeFix.Handle_ShapeFix_FixSmallSolid_Create()

def Handle_ShapeFix_FixSmallSolid_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_FixSmallSolid >":
    return _ShapeFix.Handle_ShapeFix_FixSmallSolid_DownCast(t)

def Handle_ShapeFix_FixSmallSolid_IsNull(t: "opencascade::handle< ShapeFix_FixSmallSolid > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_FixSmallSolid_IsNull(t)

def Handle_ShapeFix_Shape_Create() -> "opencascade::handle< ShapeFix_Shape >":
    return _ShapeFix.Handle_ShapeFix_Shape_Create()

def Handle_ShapeFix_Shape_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_Shape >":
    return _ShapeFix.Handle_ShapeFix_Shape_DownCast(t)

def Handle_ShapeFix_Shape_IsNull(t: "opencascade::handle< ShapeFix_Shape > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_Shape_IsNull(t)

def Handle_ShapeFix_Shell_Create() -> "opencascade::handle< ShapeFix_Shell >":
    return _ShapeFix.Handle_ShapeFix_Shell_Create()

def Handle_ShapeFix_Shell_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_Shell >":
    return _ShapeFix.Handle_ShapeFix_Shell_DownCast(t)

def Handle_ShapeFix_Shell_IsNull(t: "opencascade::handle< ShapeFix_Shell > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_Shell_IsNull(t)

def Handle_ShapeFix_Solid_Create() -> "opencascade::handle< ShapeFix_Solid >":
    return _ShapeFix.Handle_ShapeFix_Solid_Create()

def Handle_ShapeFix_Solid_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_Solid >":
    return _ShapeFix.Handle_ShapeFix_Solid_DownCast(t)

def Handle_ShapeFix_Solid_IsNull(t: "opencascade::handle< ShapeFix_Solid > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_Solid_IsNull(t)

def Handle_ShapeFix_SplitCommonVertex_Create() -> "opencascade::handle< ShapeFix_SplitCommonVertex >":
    return _ShapeFix.Handle_ShapeFix_SplitCommonVertex_Create()

def Handle_ShapeFix_SplitCommonVertex_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_SplitCommonVertex >":
    return _ShapeFix.Handle_ShapeFix_SplitCommonVertex_DownCast(t)

def Handle_ShapeFix_SplitCommonVertex_IsNull(t: "opencascade::handle< ShapeFix_SplitCommonVertex > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_SplitCommonVertex_IsNull(t)

def Handle_ShapeFix_Wire_Create() -> "opencascade::handle< ShapeFix_Wire >":
    return _ShapeFix.Handle_ShapeFix_Wire_Create()

def Handle_ShapeFix_Wire_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_Wire >":
    return _ShapeFix.Handle_ShapeFix_Wire_DownCast(t)

def Handle_ShapeFix_Wire_IsNull(t: "opencascade::handle< ShapeFix_Wire > const &") -> "bool":
    return _ShapeFix.Handle_ShapeFix_Wire_IsNull(t)

def Handle_ShapeFix_Wireframe_Create() -> "opencascade::handle< ShapeFix_Wireframe >":
    return _ShapeFix.Handle_ShapeFix_Wireframe_Create()

def Handle_ShapeFix_Wireframe_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< ShapeFix_Wireframe >":
    return _ShapeFix.Handle_ShapeFix_Wireframe_DownCast(t)

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

    def begin(self) -> "NCollection_DataMap< TopoDS_Shape,Bnd_Box2d,TopTools_ShapeMapHasher >::iterator":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_begin(self)

    def end(self) -> "NCollection_DataMap< TopoDS_Shape,Bnd_Box2d,TopTools_ShapeMapHasher >::iterator":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_end(self)

    def cbegin(self) -> "NCollection_DataMap< TopoDS_Shape,Bnd_Box2d,TopTools_ShapeMapHasher >::const_iterator":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_cbegin(self)

    def cend(self) -> "NCollection_DataMap< TopoDS_Shape,Bnd_Box2d,TopTools_ShapeMapHasher >::const_iterator":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_cend(self)

    def __init__(self, *args):
        _ShapeFix.ShapeFix_DataMapOfShapeBox2d_swiginit(self, _ShapeFix.new_ShapeFix_DataMapOfShapeBox2d(*args))

    def Exchange(self, theOther: "ShapeFix_DataMapOfShapeBox2d") -> "void":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_Exchange(self, theOther)

    def Assign(self, theOther: "ShapeFix_DataMapOfShapeBox2d") -> "NCollection_DataMap< TopoDS_Shape,Bnd_Box2d,TopTools_ShapeMapHasher > &":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_Assign(self, theOther)

    def Set(self, theOther: "ShapeFix_DataMapOfShapeBox2d") -> "NCollection_DataMap< TopoDS_Shape,Bnd_Box2d,TopTools_ShapeMapHasher > &":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_Set(self, theOther)

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

    def Bind(self, theKey: "TopoDS_Shape", theItem: "Bnd_Box2d") -> "Standard_Boolean":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_Bind(self, theKey, theItem)

    def Bound(self, theKey: "TopoDS_Shape", theItem: "Bnd_Box2d") -> "Bnd_Box2d *":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "TopoDS_Shape") -> "Standard_Boolean":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_IsBound(self, theKey)

    def UnBind(self, theKey: "TopoDS_Shape") -> "Standard_Boolean":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_UnBind(self, theKey)

    def Seek(self, theKey: "TopoDS_Shape") -> "Bnd_Box2d const *":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_Find(self, *args)

    def ChangeSeek(self, theKey: "TopoDS_Shape") -> "Bnd_Box2d *":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "TopoDS_Shape") -> "Bnd_Box2d &":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_ChangeFind(self, theKey)

    def __call__(self, *args) -> "Bnd_Box2d &":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_Clear(self, *args)
    __swig_destroy__ = _ShapeFix.delete_ShapeFix_DataMapOfShapeBox2d

    def Size(self) -> "Standard_Integer":
        return _ShapeFix.ShapeFix_DataMapOfShapeBox2d_Size(self)

# Register ShapeFix_DataMapOfShapeBox2d in _ShapeFix:
_ShapeFix.ShapeFix_DataMapOfShapeBox2d_swigregister(ShapeFix_DataMapOfShapeBox2d)

class ShapeFix_SequenceOfWireSegment(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< ShapeFix_WireSegment >::iterator":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_begin(self)

    def end(self) -> "NCollection_Sequence< ShapeFix_WireSegment >::iterator":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_end(self)

    def cbegin(self) -> "NCollection_Sequence< ShapeFix_WireSegment >::const_iterator":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_cbegin(self)

    def cend(self) -> "NCollection_Sequence< ShapeFix_WireSegment >::const_iterator":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_cend(self)

    def __init__(self, *args):
        _ShapeFix.ShapeFix_SequenceOfWireSegment_swiginit(self, _ShapeFix.new_ShapeFix_SequenceOfWireSegment(*args))

    def Size(self) -> "Standard_Integer":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Size(self)

    def Length(self) -> "Standard_Integer":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_IsEmpty(self)

    def Reverse(self) -> "void":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Reverse(self)

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

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

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

    def Assign(self, theOther: "ShapeFix_SequenceOfWireSegment") -> "NCollection_Sequence< ShapeFix_WireSegment > &":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Assign(self, theOther)

    def Set(self, theOther: "ShapeFix_SequenceOfWireSegment") -> "NCollection_Sequence< ShapeFix_WireSegment > &":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "ShapeFix_SequenceOfWireSegment") -> "void":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Split(self, theIndex, theSeq)

    def First(self) -> "ShapeFix_WireSegment const &":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_First(self)

    def ChangeFirst(self) -> "ShapeFix_WireSegment &":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_ChangeFirst(self)

    def Last(self) -> "ShapeFix_WireSegment const &":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Last(self)

    def ChangeLast(self) -> "ShapeFix_WireSegment &":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "ShapeFix_WireSegment const &":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "ShapeFix_WireSegment &":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "ShapeFix_WireSegment &":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "ShapeFix_WireSegment const &") -> "void":
        return _ShapeFix.ShapeFix_SequenceOfWireSegment_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _ShapeFix.delete_ShapeFix_SequenceOfWireSegment

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


# Register ShapeFix_SequenceOfWireSegment in _ShapeFix:
_ShapeFix.ShapeFix_SequenceOfWireSegment_swigregister(ShapeFix_SequenceOfWireSegment)

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

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

    @staticmethod
    def EncodeRegularity(*args) -> "void":
        r"""
        Runs encoderegularity from breplib taking into account shared components of assemblies, so that each component is processed only once.

        Parameters
        ----------
        shape: TopoDS_Shape
        tolang: float,optional
        	default value is 1.0e-10

        Returns
        -------
        None

        """
        return _ShapeFix.shapefix_EncodeRegularity(*args)

    @staticmethod
    def FixVertexPosition(*args) -> "Standard_Boolean":
        r"""
        Fix position of the vertices having tolerance more tnan specified one.;.

        Parameters
        ----------
        theshape: TopoDS_Shape
        theTolerance: float
        thecontext: ShapeBuild_ReShape

        Returns
        -------
        bool

        """
        return _ShapeFix.shapefix_FixVertexPosition(*args)

    @staticmethod
    def LeastEdgeSize(*args) -> "Standard_Real":
        r"""
        Calculate size of least edge;.

        Parameters
        ----------
        theshape: TopoDS_Shape

        Returns
        -------
        float

        """
        return _ShapeFix.shapefix_LeastEdgeSize(*args)

    @staticmethod
    def RemoveSmallEdges(*args) -> "TopoDS_Shape":
        r"""
        Removes edges which are less than given tolerance from shape with help of shapefix_wire::fixsmall().

        Parameters
        ----------
        shape: TopoDS_Shape
        Tolerance: float
        context: ShapeBuild_ReShape

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.shapefix_RemoveSmallEdges(*args)

    @staticmethod
    def SameParameter(*args) -> "Standard_Boolean":
        r"""
        Runs sameparameter from breplib with these adaptations : <enforce> forces computations, else they are made only on edges with flag sameparameter false <preci>, if not precised, is taken for each edge as its own tolerance returns true when done, false if an exception has been raised in case of exception anyway, as many edges as possible have been processed. the passed progress indicator allows user to consult the current progress stage and abort algorithm if needed.

        Parameters
        ----------
        shape: TopoDS_Shape
        enforce: bool
        preci: float,optional
        	default value is 0.0
        theProgress: Message_ProgressRange,optional
        	default value is Message_ProgressRange()
        theMsgReg: ShapeExtend_BasicMsgRegistrator,optional
        	default value is 0

        Returns
        -------
        bool

        """
        return _ShapeFix.shapefix_SameParameter(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _ShapeFix.shapefix_swiginit(self, _ShapeFix.new_shapefix())
    __swig_destroy__ = _ShapeFix.delete_shapefix

# Register shapefix in _ShapeFix:
_ShapeFix.shapefix_swigregister(shapefix)

def shapefix_EncodeRegularity(*args) -> "void":
    r"""
    Runs encoderegularity from breplib taking into account shared components of assemblies, so that each component is processed only once.

    Parameters
    ----------
    shape: TopoDS_Shape
    tolang: float,optional
    	default value is 1.0e-10

    Returns
    -------
    None

    """
    return _ShapeFix.shapefix_EncodeRegularity(*args)

def shapefix_FixVertexPosition(*args) -> "Standard_Boolean":
    r"""
    Fix position of the vertices having tolerance more tnan specified one.;.

    Parameters
    ----------
    theshape: TopoDS_Shape
    theTolerance: float
    thecontext: ShapeBuild_ReShape

    Returns
    -------
    bool

    """
    return _ShapeFix.shapefix_FixVertexPosition(*args)

def shapefix_LeastEdgeSize(*args) -> "Standard_Real":
    r"""
    Calculate size of least edge;.

    Parameters
    ----------
    theshape: TopoDS_Shape

    Returns
    -------
    float

    """
    return _ShapeFix.shapefix_LeastEdgeSize(*args)

def shapefix_RemoveSmallEdges(*args) -> "TopoDS_Shape":
    r"""
    Removes edges which are less than given tolerance from shape with help of shapefix_wire::fixsmall().

    Parameters
    ----------
    shape: TopoDS_Shape
    Tolerance: float
    context: ShapeBuild_ReShape

    Returns
    -------
    TopoDS_Shape

    """
    return _ShapeFix.shapefix_RemoveSmallEdges(*args)

def shapefix_SameParameter(*args) -> "Standard_Boolean":
    r"""
    Runs sameparameter from breplib with these adaptations : <enforce> forces computations, else they are made only on edges with flag sameparameter false <preci>, if not precised, is taken for each edge as its own tolerance returns true when done, false if an exception has been raised in case of exception anyway, as many edges as possible have been processed. the passed progress indicator allows user to consult the current progress stage and abort algorithm if needed.

    Parameters
    ----------
    shape: TopoDS_Shape
    enforce: bool
    preci: float,optional
    	default value is 0.0
    theProgress: Message_ProgressRange,optional
    	default value is Message_ProgressRange()
    theMsgReg: ShapeExtend_BasicMsgRegistrator,optional
    	default value is 0

    Returns
    -------
    bool

    """
    return _ShapeFix.shapefix_SameParameter(*args)

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

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

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_Edge_swiginit(self, _ShapeFix.new_ShapeFix_Edge(*args))

    def FixAddCurve3d(self, *args) -> "Standard_Boolean":
        r"""
        Tries to build 3d curve of the edge if missing use : it is to be called after fixremovecurve3d (if removed) or in any case when edge can have no 3d curve returns: true if 3d curve was added, else false status : ok : 3d curve exists fail1: breplib::buildcurve3d() has failed done1: 3d curve was added.

        Parameters
        ----------
        edge: TopoDS_Edge

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Edge_FixAddCurve3d(self, *args)

    def FixAddPCurve(self, *args) -> "Standard_Boolean":
        r"""
        See method below for information.

        Parameters
        ----------
        edge: TopoDS_Edge
        face: TopoDS_Face
        isSeam: bool
        prec: float,optional
        	default value is 0.0

        Returns
        -------
        bool
        See method below for information.

        Parameters
        ----------
        edge: TopoDS_Edge
        surface: Geom_Surface
        location: TopLoc_Location
        isSeam: bool
        prec: float,optional
        	default value is 0.0

        Returns
        -------
        bool
        See method below for information.

        Parameters
        ----------
        edge: TopoDS_Edge
        face: TopoDS_Face
        isSeam: bool
        surfana: ShapeAnalysis_Surface
        prec: float,optional
        	default value is 0.0

        Returns
        -------
        bool
        Adds pcurve(s) of the edge if missing (by projecting 3d curve) parameter isseam indicates if the edge is a seam. the parameter <prec> defines the precision for calculations. if it is 0 (default), the tolerance of the edge is taken. remark : this method is rather for internal use since it accepts parameter <surfana> for optimization of computations use : it is to be called after fixremovepcurve (if removed) or in any case when edge can have no pcurve returns: true if pcurve was added, else false status : ok : pcurve exists fail1: no 3d curve fail2: fail during projecting done1: pcurve was added done2: specific case of pcurve going through degenerated point on sphere encountered during projection (see class shapeconstruct_projectcurveonsurface for more info).

        Parameters
        ----------
        edge: TopoDS_Edge
        surface: Geom_Surface
        location: TopLoc_Location
        isSeam: bool
        surfana: ShapeAnalysis_Surface
        prec: float,optional
        	default value is 0.0

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Edge_FixAddPCurve(self, *args)

    def FixRemoveCurve3d(self, *args) -> "Standard_Boolean":
        r"""
        Removes 3d curve of the edge if it does not match the vertices returns: true, if does not match, removed (status done) false, (status ok) if matches or (status fail) if no 3d curve, nothing done.

        Parameters
        ----------
        edge: TopoDS_Edge

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Edge_FixRemoveCurve3d(self, *args)

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

        Parameters
        ----------
        edge: TopoDS_Edge
        face: TopoDS_Face

        Returns
        -------
        bool
        Removes the pcurve(s) of the edge if it does not match the vertices check is done use : it is to be called when pcurve of an edge can be wrong (e.g., after import from iges) returns: true, if does not match, removed (status done) false, (status ok) if matches or (status fail) if no pcurve, nothing done.

        Parameters
        ----------
        edge: TopoDS_Edge
        surface: Geom_Surface
        location: TopLoc_Location

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Edge_FixRemovePCurve(self, *args)

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

        Parameters
        ----------
        edge: TopoDS_Edge
        face: TopoDS_Face

        Returns
        -------
        bool
        Fixes edge if pcurve is directed opposite to 3d curve check is done by call to the function shapeanalysis_edge::checkcurve3dwithpcurve() warning: for seam edge this method will check and fix the pcurve in only one direction. hence, it should be called twice for seam edge: once with edge orientation forward and once with reversed. returns: false if nothing done, true if reversed (status done) status: ok - pcurve ok, nothing done fail1 - no pcurve fail2 - no 3d curve done1 - pcurve was reversed.

        Parameters
        ----------
        edge: TopoDS_Edge
        surface: Geom_Surface
        location: TopLoc_Location

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Edge_FixReversed2d(self, *args)

    def FixSameParameter(self, *args) -> "Standard_Boolean":
        r"""
        Tries to make edge sameparameter and sets corresponding tolerance and sameparameter flag. first, it makes edge same range if samerange flag is not set. //! if flag sameparameter is set, this method calls the function shapeanalysis_edge::checksameparameter() that calculates the maximal deviation of pcurves of the edge from its 3d curve. if deviation > tolerance, the tolerance of edge is increased to a value of deviation. if deviation < tolerance nothing happens. //! if flag sameparameter is not set, this method chooses the best variant (one that has minimal tolerance), either a. only after computing deviation (as above) or b. after calling standard procedure breplib::sameparameter and computing deviation (as above). if <tolerance> > 0, it is used as parameter for breplib::sameparameter, otherwise, tolerance of the edge is used. //! use : is to be called after all pcurves and 3d curve of the edge are correctly computed remark : sameparameter flag is always set to true after this method returns: true, if something done, else false status : ok - edge was initially sameparameter, nothing is done fail1 - computation of deviation of pcurves from 3d curve has failed fail2 - breplib::sameparameter() has failed done1 - tolerance of the edge was increased done2 - flag sameparameter was set to true (only if breplib::sameparameter() did not set it) done3 - edge was modified by breplib::sameparameter() to sameparameter done4 - not used anymore done5 - if the edge resulting from breplib has been chosen, i.e. variant b. above (only for edges with not set sameparameter).

        Parameters
        ----------
        edge: TopoDS_Edge
        tolerance: float,optional
        	default value is 0.0

        Returns
        -------
        bool
        Tries to make edge sameparameter and sets corresponding tolerance and sameparameter flag. first, it makes edge same range if samerange flag is not set. //! if flag sameparameter is set, this method calls the function shapeanalysis_edge::checksameparameter() that calculates the maximal deviation of pcurves of the edge from its 3d curve. if deviation > tolerance, the tolerance of edge is increased to a value of deviation. if deviation < tolerance nothing happens. //! if flag sameparameter is not set, this method chooses the best variant (one that has minimal tolerance), either a. only after computing deviation (as above) or b. after calling standard procedure breplib::sameparameter and computing deviation (as above). if <tolerance> > 0, it is used as parameter for breplib::sameparameter, otherwise, tolerance of the edge is used. //! use : is to be called after all pcurves and 3d curve of the edge are correctly computed remark : sameparameter flag is always set to true after this method returns: true, if something done, else false status : ok - edge was initially sameparameter, nothing is done fail1 - computation of deviation of pcurves from 3d curve has failed fail2 - breplib::sameparameter() has failed done1 - tolerance of the edge was increased done2 - flag sameparameter was set to true (only if breplib::sameparameter() did not set it) done3 - edge was modified by breplib::sameparameter() to sameparameter done4 - not used anymore done5 - if the edge resulting from breplib has been chosen, i.e. variant b. above (only for edges with not set sameparameter).

        Parameters
        ----------
        edge: TopoDS_Edge
        face: TopoDS_Face
        tolerance: float,optional
        	default value is 0.0

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Edge_FixSameParameter(self, *args)

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

        Parameters
        ----------
        edge: TopoDS_Edge
        face: TopoDS_Face

        Returns
        -------
        bool
        Increases the tolerances of the edge vertices to comprise the ends of 3d curve and pcurve on the given face (first method) or all pcurves stored in an edge (second one) returns: true, if tolerances have been increased, otherwise false status: ok : the original tolerances have not been changed done1: the tolerance of first vertex has been increased done2: the tolerance of last vertex has been increased.

        Parameters
        ----------
        edge: TopoDS_Edge

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Edge_FixVertexTolerance(self, *args)

    def Projector(self, *args) -> "opencascade::handle< ShapeConstruct_ProjectCurveOnSurface >":
        r"""
        Returns the projector used for recomputing missing pcurves can be used for adjusting parameters of projector.

        Returns
        -------
        opencascade::handle<ShapeConstruct_ProjectCurveOnSurface>

        """
        return _ShapeFix.ShapeFix_Edge_Projector(self, *args)

    def SetContext(self, *args) -> "void":
        r"""
        Sets context.

        Parameters
        ----------
        context: ShapeBuild_ReShape

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Edge_SetContext(self, *args)

    def Status(self, *args) -> "Standard_Boolean":
        r"""
        Returns the status (in the form of true/false) of last fix.

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Edge_Status(self, *args)


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


    __repr__ = _dumps_object

    @methodnotwrapped
    def Context(self):
    	pass

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_Edge

# Register ShapeFix_Edge in _ShapeFix:
_ShapeFix.ShapeFix_Edge_swigregister(ShapeFix_Edge)

class ShapeFix_EdgeConnect(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

        """
        _ShapeFix.ShapeFix_EdgeConnect_swiginit(self, _ShapeFix.new_ShapeFix_EdgeConnect(*args))

    def Add(self, *args) -> "void":
        r"""
        Adds information on connectivity between start vertex of second edge and end vertex of first edge, taking edges orientation into account.

        Parameters
        ----------
        aFirst: TopoDS_Edge
        aSecond: TopoDS_Edge

        Returns
        -------
        None
        Adds connectivity information for the whole shape. note: edges in wires must be well ordered note: flag closed should be set for closed wires.

        Parameters
        ----------
        aShape: TopoDS_Shape

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_EdgeConnect_Add(self, *args)

    def Build(self, *args) -> "void":
        r"""
        Builds shared vertices, updates their positions and tolerances.

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_EdgeConnect_Build(self, *args)

    def Clear(self, *args) -> "void":
        r"""
        Clears internal data structure.

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_EdgeConnect_Clear(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_EdgeConnect

# Register ShapeFix_EdgeConnect in _ShapeFix:
_ShapeFix.ShapeFix_EdgeConnect_swigregister(ShapeFix_EdgeConnect)

class ShapeFix_EdgeProjAux(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
        ----------
        F: TopoDS_Face
        E: TopoDS_Edge

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_EdgeProjAux_swiginit(self, _ShapeFix.new_ShapeFix_EdgeProjAux(*args))

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

        Parameters
        ----------
        preci: float

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_EdgeProjAux_Compute(self, *args)

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

        Returns
        -------
        float

        """
        return _ShapeFix.ShapeFix_EdgeProjAux_FirstParam(self, *args)

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

        Parameters
        ----------
        F: TopoDS_Face
        E: TopoDS_Edge

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_EdgeProjAux_Init(self, *args)

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

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_EdgeProjAux_IsFirstDone(self, *args)

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

        Parameters
        ----------
        C: Geom2d_Curve

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_EdgeProjAux_IsIso(self, *args)

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

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_EdgeProjAux_IsLastDone(self, *args)

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

        Returns
        -------
        float

        """
        return _ShapeFix.ShapeFix_EdgeProjAux_LastParam(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_EdgeProjAux

# Register ShapeFix_EdgeProjAux in _ShapeFix:
_ShapeFix.ShapeFix_EdgeProjAux_swigregister(ShapeFix_EdgeProjAux)

class ShapeFix_FaceConnect(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

        """
        _ShapeFix.ShapeFix_FaceConnect_swiginit(self, _ShapeFix.new_ShapeFix_FaceConnect(*args))

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

        Parameters
        ----------
        aFirst: TopoDS_Face
        aSecond: TopoDS_Face

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_FaceConnect_Add(self, *args)

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

        Parameters
        ----------
        shell: TopoDS_Shell
        sewtoler: float
        fixtoler: float

        Returns
        -------
        TopoDS_Shell

        """
        return _ShapeFix.ShapeFix_FaceConnect_Build(self, *args)

    def Clear(self, *args) -> "void":
        r"""
        Clears internal data structure.

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_FaceConnect_Clear(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_FaceConnect

# Register ShapeFix_FaceConnect in _ShapeFix:
_ShapeFix.ShapeFix_FaceConnect_swigregister(ShapeFix_FaceConnect)

class ShapeFix_FreeBounds(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
        Builds forecasting free bounds of the <shape> and connects open wires with tolerance <closetoler>. <shape> should be a compound of faces. tolerance <closetoler> should be greater than tolerance <sewtoler> used for initializing sewing analyzer, otherwise connection of open wires is not performed.

        Parameters
        ----------
        shape: TopoDS_Shape
        sewtoler: float
        closetoler: float
        splitclosed: bool
        splitopen: bool

        Returns
        -------
        None
        Builds actual free bounds of the <shape> and connects open wires with tolerance <closetoler>. <shape> should be a compound of shells.

        Parameters
        ----------
        shape: TopoDS_Shape
        closetoler: float
        splitclosed: bool
        splitopen: bool

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_FreeBounds_swiginit(self, _ShapeFix.new_ShapeFix_FreeBounds(*args))

    def GetClosedWires(self, *args) -> "TopoDS_Compound const":
        r"""
        Returns compound of closed wires out of free edges.

        Returns
        -------
        TopoDS_Compound

        """
        return _ShapeFix.ShapeFix_FreeBounds_GetClosedWires(self, *args)

    def GetOpenWires(self, *args) -> "TopoDS_Compound const":
        r"""
        Returns compound of open wires out of free edges.

        Returns
        -------
        TopoDS_Compound

        """
        return _ShapeFix.ShapeFix_FreeBounds_GetOpenWires(self, *args)

    def GetShape(self, *args) -> "TopoDS_Shape const":
        r"""
        Returns modified source shape.

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_FreeBounds_GetShape(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_FreeBounds

# Register ShapeFix_FreeBounds in _ShapeFix:
_ShapeFix.ShapeFix_FreeBounds_swigregister(ShapeFix_FreeBounds)

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

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

        Parameters
        ----------
        context: ShapeBuild_ReShape
        preci: float
        maxtol: float,optional
        	default value is 1.0

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_IntersectionTool_swiginit(self, _ShapeFix.new_ShapeFix_IntersectionTool(*args))

    def Context(self, *args) -> "opencascade::handle< ShapeBuild_ReShape >":
        r"""
        Returns context.

        Returns
        -------
        opencascade::handle<ShapeBuild_ReShape>

        """
        return _ShapeFix.ShapeFix_IntersectionTool_Context(self, *args)

    def CutEdge(self, *args) -> "Standard_Boolean":
        r"""
        Cut edge by parameters pend and cut.

        Parameters
        ----------
        edge: TopoDS_Edge
        pend: float
        cut: float
        face: TopoDS_Face

        Returns
        -------
        iscutline: bool

        """
        return _ShapeFix.ShapeFix_IntersectionTool_CutEdge(self, *args)

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

        Parameters
        ----------
        face: TopoDS_Face

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_IntersectionTool_FixIntersectingWires(self, *args)

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

        Parameters
        ----------
        sewd: ShapeExtend_WireData
        face: TopoDS_Face

        Returns
        -------
        NbSplit: int
        NbCut: int
        NbRemoved: int

        """
        return _ShapeFix.ShapeFix_IntersectionTool_FixSelfIntersectWire(self, *args)

    def SplitEdge(self, *args) -> "Standard_Boolean":
        r"""
        Split edge on two new edges using new vertex 'vert' and 'param' - parameter for splitting the 'face' is necessary for pcurves and using transferparameterproj.

        Parameters
        ----------
        edge: TopoDS_Edge
        param: float
        vert: TopoDS_Vertex
        face: TopoDS_Face
        newE1: TopoDS_Edge
        newE2: TopoDS_Edge
        preci: float

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_IntersectionTool_SplitEdge(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_IntersectionTool

# Register ShapeFix_IntersectionTool in _ShapeFix:
_ShapeFix.ShapeFix_IntersectionTool_swigregister(ShapeFix_IntersectionTool)

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

    def __init__(self, *args):
        r"""
        Empty constructor (no context is created).

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_Root_swiginit(self, _ShapeFix.new_ShapeFix_Root(*args))

    def Context(self, *args) -> "opencascade::handle< ShapeBuild_ReShape >":
        r"""
        Returns context.

        Returns
        -------
        opencascade::handle<ShapeBuild_ReShape>

        """
        return _ShapeFix.ShapeFix_Root_Context(self, *args)

    def LimitTolerance(self, *args) -> "Standard_Real":
        r"""
        Returns tolerance limited by [mymintol,mymaxtol].

        Parameters
        ----------
        toler: float

        Returns
        -------
        float

        """
        return _ShapeFix.ShapeFix_Root_LimitTolerance(self, *args)

    def MaxTolerance(self, *args) -> "Standard_Real":
        r"""
        Returns maximal allowed tolerance.

        Returns
        -------
        float

        """
        return _ShapeFix.ShapeFix_Root_MaxTolerance(self, *args)

    def MinTolerance(self, *args) -> "Standard_Real":
        r"""
        Returns minimal allowed tolerance.

        Returns
        -------
        float

        """
        return _ShapeFix.ShapeFix_Root_MinTolerance(self, *args)

    def MsgRegistrator(self, *args) -> "opencascade::handle< ShapeExtend_BasicMsgRegistrator >":
        r"""
        Returns message registrator.

        Returns
        -------
        opencascade::handle<ShapeExtend_BasicMsgRegistrator>

        """
        return _ShapeFix.ShapeFix_Root_MsgRegistrator(self, *args)

    def Precision(self, *args) -> "Standard_Real":
        r"""
        Returns basic precision value.

        Returns
        -------
        float

        """
        return _ShapeFix.ShapeFix_Root_Precision(self, *args)

    def SendFail(self, *args) -> "void":
        r"""
        Sends a fail to be attached to the shape. calls sendmsg with gravity set to message_fail.

        Parameters
        ----------
        shape: TopoDS_Shape
        message: Message_Msg

        Returns
        -------
        None
        Calls previous method for myshape.

        Parameters
        ----------
        message: Message_Msg

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Root_SendFail(self, *args)

    def SendMsg(self, *args) -> "void":
        r"""
        Sends a message to be attached to the shape. calls corresponding message of message registrator.

        Parameters
        ----------
        shape: TopoDS_Shape
        message: Message_Msg
        gravity: Message_Gravity,optional
        	default value is Message_Info

        Returns
        -------
        None
        Sends a message to be attached to myshape. calls previous method.

        Parameters
        ----------
        message: Message_Msg
        gravity: Message_Gravity,optional
        	default value is Message_Info

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Root_SendMsg(self, *args)

    def SendWarning(self, *args) -> "void":
        r"""
        Sends a warning to be attached to the shape. calls sendmsg with gravity set to message_warning.

        Parameters
        ----------
        shape: TopoDS_Shape
        message: Message_Msg

        Returns
        -------
        None
        Calls previous method for myshape.

        Parameters
        ----------
        message: Message_Msg

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Root_SendWarning(self, *args)

    def Set(self, *args) -> "void":
        r"""
        Copy all fields from another root object.

        Parameters
        ----------
        Root: ShapeFix_Root

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Root_Set(self, *args)

    def SetContext(self, *args) -> "void":
        r"""
        Sets context.

        Parameters
        ----------
        context: ShapeBuild_ReShape

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Root_SetContext(self, *args)

    def SetMaxTolerance(self, *args) -> "void":
        r"""
        Sets maximal allowed tolerance.

        Parameters
        ----------
        maxtol: float

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Root_SetMaxTolerance(self, *args)

    def SetMinTolerance(self, *args) -> "void":
        r"""
        Sets minimal allowed tolerance.

        Parameters
        ----------
        mintol: float

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Root_SetMinTolerance(self, *args)

    def SetMsgRegistrator(self, *args) -> "void":
        r"""
        Sets message registrator.

        Parameters
        ----------
        msgreg: ShapeExtend_BasicMsgRegistrator

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Root_SetMsgRegistrator(self, *args)

    def SetPrecision(self, *args) -> "void":
        r"""
        Sets basic precision value.

        Parameters
        ----------
        preci: float

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Root_SetPrecision(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_Root

# Register ShapeFix_Root in _ShapeFix:
_ShapeFix.ShapeFix_Root_swigregister(ShapeFix_Root)

class ShapeFix_ShapeTolerance(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

        """
        _ShapeFix.ShapeFix_ShapeTolerance_swiginit(self, _ShapeFix.new_ShapeFix_ShapeTolerance(*args))

    def LimitTolerance(self, *args) -> "Standard_Boolean":
        r"""
        Limits tolerances in a shape as follows : tmin = tmax -> as settolerance (forces) tmin = 0 -> maximum tolerance will be <tmax> tmax = 0 or not given (more generally, tmax < tmin) -> <tmax> ignored, minimum will be <tmin> else, maximum will be <max> and minimum will be <min> styp = vertex : only vertices are set styp = edge : only edges are set styp = face : only faces are set styp = wire : to have edges and their vertices set styp = other value : all (vertices,edges,faces) are set returns true if at least one tolerance of the sub-shape has been modified.

        Parameters
        ----------
        shape: TopoDS_Shape
        tmin: float
        tmax: float,optional
        	default value is 0.0
        styp: TopAbs_ShapeEnum,optional
        	default value is TopAbs_SHAPE

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_ShapeTolerance_LimitTolerance(self, *args)

    def SetTolerance(self, *args) -> "void":
        r"""
        Sets (enforces) tolerances in a shape to the given value styp = vertex : only vertices are set styp = edge : only edges are set styp = face : only faces are set styp = wire : to have edges and their vertices set styp = other value : all (vertices,edges,faces) are set.

        Parameters
        ----------
        shape: TopoDS_Shape
        preci: float
        styp: TopAbs_ShapeEnum,optional
        	default value is TopAbs_SHAPE

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_ShapeTolerance_SetTolerance(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_ShapeTolerance

# Register ShapeFix_ShapeTolerance in _ShapeFix:
_ShapeFix.ShapeFix_ShapeTolerance_swigregister(ShapeFix_ShapeTolerance)

class ShapeFix_SplitTool(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

        """
        _ShapeFix.ShapeFix_SplitTool_swiginit(self, _ShapeFix.new_ShapeFix_SplitTool(*args))

    def CutEdge(self, *args) -> "Standard_Boolean":
        r"""
        Cut edge by parameters pend and cut.

        Parameters
        ----------
        edge: TopoDS_Edge
        pend: float
        cut: float
        face: TopoDS_Face

        Returns
        -------
        iscutline: bool

        """
        return _ShapeFix.ShapeFix_SplitTool_CutEdge(self, *args)

    def SplitEdge(self, *args) -> "Standard_Boolean":
        r"""
        Split edge on two new edges using new vertex 'vert' and 'param' - parameter for splitting the 'face' is necessary for pcurves and using transferparameterproj.

        Parameters
        ----------
        edge: TopoDS_Edge
        param: float
        vert: TopoDS_Vertex
        face: TopoDS_Face
        newE1: TopoDS_Edge
        newE2: TopoDS_Edge
        tol3d: float
        tol2d: float

        Returns
        -------
        bool
        Split edge on two new edges using new vertex 'vert' and 'param1' and 'param2' - parameter for splitting and cutting the 'face' is necessary for pcurves and using transferparameterproj.

        Parameters
        ----------
        edge: TopoDS_Edge
        param1: float
        param2: float
        vert: TopoDS_Vertex
        face: TopoDS_Face
        newE1: TopoDS_Edge
        newE2: TopoDS_Edge
        tol3d: float
        tol2d: float

        Returns
        -------
        bool
        Split edge on two new edges using two new vertex v1 and v2 and two parameters for splitting - fp and lp correspondingly the 'face' is necessary for pcurves and using transferparameterproj anum - number of edge in seqe which corresponding to [fp,lp].

        Parameters
        ----------
        edge: TopoDS_Edge
        fp: float
        V1: TopoDS_Vertex
        lp: float
        V2: TopoDS_Vertex
        face: TopoDS_Face
        SeqE: TopTools_SequenceOfShape
        context: ShapeBuild_ReShape
        tol3d: float
        tol2d: float

        Returns
        -------
        aNum: int

        """
        return _ShapeFix.ShapeFix_SplitTool_SplitEdge(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_SplitTool

# Register ShapeFix_SplitTool in _ShapeFix:
_ShapeFix.ShapeFix_SplitTool_swigregister(ShapeFix_SplitTool)

class ShapeFix_WireVertex(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

        """
        _ShapeFix.ShapeFix_WireVertex_swiginit(self, _ShapeFix.new_ShapeFix_WireVertex(*args))

    def Analyzer(self, *args) -> "ShapeAnalysis_WireVertex const &":
        r"""
        Returns internal analyzer.

        Returns
        -------
        ShapeAnalysis_WireVertex

        """
        return _ShapeFix.ShapeFix_WireVertex_Analyzer(self, *args)

    def Fix(self, *args) -> "Standard_Integer":
        r"""
        Fixes all statuses except 'disjoined', i.e. the cases in which a common value has been set, with or without changing parameters returns the count of fixed vertices, 0 if none.

        Returns
        -------
        int

        """
        return _ShapeFix.ShapeFix_WireVertex_Fix(self, *args)

    def FixSame(self, *args) -> "Standard_Integer":
        r"""
        Fixes 'same' or 'close' status (same vertex may be set, without changing parameters) returns the count of fixed vertices, 0 if none.

        Returns
        -------
        int

        """
        return _ShapeFix.ShapeFix_WireVertex_FixSame(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Loads the wire, ininializes internal analyzer (shapeanalysis_wirevertex) with the given precision, and performs analysis.

        Parameters
        ----------
        wire: TopoDS_Wire
        preci: float

        Returns
        -------
        None
        Loads the wire, ininializes internal analyzer (shapeanalysis_wirevertex) with the given precision, and performs analysis.

        Parameters
        ----------
        sbwd: ShapeExtend_WireData
        preci: float

        Returns
        -------
        None
        Loads all the data on wire, already analysed by shapeanalysis_wirevertex.

        Parameters
        ----------
        sawv: ShapeAnalysis_WireVertex

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_WireVertex_Init(self, *args)

    def Wire(self, *args) -> "TopoDS_Wire":
        r"""
        Returns resulting wire (fixed).

        Returns
        -------
        TopoDS_Wire

        """
        return _ShapeFix.ShapeFix_WireVertex_Wire(self, *args)

    def WireData(self, *args) -> "opencascade::handle< ShapeExtend_WireData > const &":
        r"""
        Returns data on wire (fixed).

        Returns
        -------
        opencascade::handle<ShapeExtend_WireData>

        """
        return _ShapeFix.ShapeFix_WireVertex_WireData(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_WireVertex

# Register ShapeFix_WireVertex in _ShapeFix:
_ShapeFix.ShapeFix_WireVertex_swigregister(ShapeFix_WireVertex)

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

    def __init__(self, *args):
        r"""
        Creates empty tool.

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_ComposeShell_swiginit(self, _ShapeFix.new_ShapeFix_ComposeShell(*args))

    def GetClosedMode(self) -> "Standard_Boolean":
        r"""GetClosedMode(ShapeFix_ComposeShell self) -> Standard_Boolean"""
        return _ShapeFix.ShapeFix_ComposeShell_GetClosedMode(self)

    def SetClosedMode(self, value: "Standard_Boolean") -> "void":
        r"""SetClosedMode(ShapeFix_ComposeShell self, Standard_Boolean value)"""
        return _ShapeFix.ShapeFix_ComposeShell_SetClosedMode(self, value)

    def DispatchWires(self, *args) -> "void":
        r"""
        Creates new faces from the set of (closed) wires. each wire is put on corresponding patch in the composite surface, and all pcurves on the initial (pseudo)face are reassigned to that surface. if several wires are one inside another, single face is created.

        Parameters
        ----------
        faces: TopTools_SequenceOfShape
        wires: ShapeFix_SequenceOfWireSegment

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_ComposeShell_DispatchWires(self, *args)

    def GetTransferParamTool(self, *args) -> "opencascade::handle< ShapeAnalysis_TransferParameters >":
        r"""
        Gets tool for transfer parameters from 3d to 2d and vice versa.

        Returns
        -------
        opencascade::handle<ShapeAnalysis_TransferParameters>

        """
        return _ShapeFix.ShapeFix_ComposeShell_GetTransferParamTool(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Initializes with composite surface, face and precision. here face defines both set of wires and way of getting pcurves. precision is used (together with tolerance of edges) for handling subtle cases, such as tangential intersections.

        Parameters
        ----------
        Grid: ShapeExtend_CompositeSurface
        L: TopLoc_Location
        Face: TopoDS_Face
        Prec: float

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_ComposeShell_Init(self, *args)

    def Perform(self, *args) -> "Standard_Boolean":
        r"""
        Performs the work on already loaded data.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_ComposeShell_Perform(self, *args)

    def Result(self, *args) -> "TopoDS_Shape const":
        r"""
        Returns resulting shell or face (or null shape if not done).

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_ComposeShell_Result(self, *args)

    def SetTransferParamTool(self, *args) -> "void":
        r"""
        Sets tool for transfer parameters from 3d to 2d and vice versa.

        Parameters
        ----------
        TransferParam: ShapeAnalysis_TransferParameters

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_ComposeShell_SetTransferParamTool(self, *args)

    def SplitEdges(self, *args) -> "void":
        r"""
        Splits edges in the original shape by grid. this is a part of perform() which does not produce any resulting shape; the only result is filled context where splittings are recorded. //! note: if edge is splitted, it is replaced by wire, and order of edges in the wire corresponds to forward orientation of the edge.

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_ComposeShell_SplitEdges(self, *args)

    def Status(self, *args) -> "Standard_Boolean":
        r"""
        Queries status of last call to perform() ok : nothing done (some kind of error) done1: splitting is done, at least one new face created done2: splitting is done, several new faces obtained fail1: misoriented wire encountered (handled) fail2: recoverable parity error fail3: edge with no pcurve on supporting face fail4: unrecoverable algorithm error (parity check).

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_ComposeShell_Status(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_ComposeShell

# Register ShapeFix_ComposeShell in _ShapeFix:
_ShapeFix.ShapeFix_ComposeShell_swigregister(ShapeFix_ComposeShell)

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

    def __init__(self, *args):
        r"""
        Creates an empty tool.

        Returns
        -------
        None
        Creates a tool and loads a face.

        Parameters
        ----------
        face: TopoDS_Face

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_Face_swiginit(self, _ShapeFix.new_ShapeFix_Face(*args))

    def Add(self, *args) -> "void":
        r"""
        Add a wire to current face using brep_builder. wire is added without taking into account orientation of face (as if face were forward).

        Parameters
        ----------
        wire: TopoDS_Wire

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Face_Add(self, *args)

    def GetAutoCorrectPrecisionMode(self) -> "Standard_Integer":
        r"""GetAutoCorrectPrecisionMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetAutoCorrectPrecisionMode(self)

    def SetAutoCorrectPrecisionMode(self, value: "Standard_Integer") -> "void":
        r"""SetAutoCorrectPrecisionMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetAutoCorrectPrecisionMode(self, value)

    def ClearModes(self, *args) -> "void":
        r"""
        Sets all modes to default.

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Face_ClearModes(self, *args)

    def Face(self, *args) -> "TopoDS_Face":
        r"""
        Returns a face which corresponds to the current state warning: the finally produced face may be another one ... but with the same support.

        Returns
        -------
        TopoDS_Face

        """
        return _ShapeFix.ShapeFix_Face_Face(self, *args)

    def FixAddNaturalBound(self, *args) -> "Standard_Boolean":
        r"""
        Adds natural boundary on face if it is missing. two cases are supported: - face has no wires - face lies on geometrically double-closed surface (sphere or torus) and none of wires is left-oriented returns true if natural boundary was added.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_FixAddNaturalBound(self, *args)

    def GetFixAddNaturalBoundMode(self) -> "Standard_Integer":
        r"""GetFixAddNaturalBoundMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetFixAddNaturalBoundMode(self)

    def SetFixAddNaturalBoundMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixAddNaturalBoundMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetFixAddNaturalBoundMode(self, value)

    def FixIntersectingWires(self, *args) -> "Standard_Boolean":
        r"""
        Detects and fixes the special case when face has more than one wire and this wires have intersection point.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_FixIntersectingWires(self, *args)

    def GetFixIntersectingWiresMode(self) -> "Standard_Integer":
        r"""GetFixIntersectingWiresMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetFixIntersectingWiresMode(self)

    def SetFixIntersectingWiresMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixIntersectingWiresMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetFixIntersectingWiresMode(self, value)

    def FixLoopWire(self, *args) -> "Standard_Boolean":
        r"""
        Detects if wire has a loop and fixes this situation by splitting on the few parts. if wire has a loops and it was splitted status was set to value shapeextend_done6.

        Parameters
        ----------
        aResWires: TopTools_SequenceOfShape

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_FixLoopWire(self, *args)

    def GetFixLoopWiresMode(self) -> "Standard_Integer":
        r"""GetFixLoopWiresMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetFixLoopWiresMode(self)

    def SetFixLoopWiresMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixLoopWiresMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetFixLoopWiresMode(self, value)

    def FixMissingSeam(self, *args) -> "Standard_Boolean":
        r"""
        Detects and fixes the special case when face on a closed surface is given by two wires closed in 3d but with gap in 2d. in that case it creates a new wire from the two, and adds a missing seam edge returns true if missing seam was added.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_FixMissingSeam(self, *args)

    def GetFixMissingSeamMode(self) -> "Standard_Integer":
        r"""GetFixMissingSeamMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetFixMissingSeamMode(self)

    def SetFixMissingSeamMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixMissingSeamMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetFixMissingSeamMode(self, value)

    def FixOrientation(self, *args) -> "Standard_Boolean":
        r"""
        Fixes orientation of wires on the face it tries to make all wires lie outside all others (according to orientation) by reversing orientation of some of them. if face lying on sphere or torus has single wire and addnaturalboundmode is true, that wire is not reversed in any case (supposing that natural bound will be added). returns true if wires were reversed.

        Returns
        -------
        bool
        Fixes orientation of wires on the face it tries to make all wires lie outside all others (according to orientation) by reversing orientation of some of them. if face lying on sphere or torus has single wire and addnaturalboundmode is true, that wire is not reversed in any case (supposing that natural bound will be added). returns true if wires were reversed outwires return information about out wires + list of internal wires for each (for performing split face).

        Parameters
        ----------
        MapWires: TopTools_DataMapOfShapeListOfShape

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_FixOrientation(self, *args)

    def GetFixOrientationMode(self) -> "Standard_Integer":
        r"""GetFixOrientationMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetFixOrientationMode(self)

    def SetFixOrientationMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixOrientationMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetFixOrientationMode(self, value)

    def FixPeriodicDegenerated(self, *args) -> "Standard_Boolean":
        r"""
        Fixes topology for a specific case when face is composed by a single wire belting a periodic surface. in that case a degenerated edge is reconstructed in the degenerated pole of the surface. initial wire gets consistent orientation. must be used in couple and before fixmissingseam routine.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_FixPeriodicDegenerated(self, *args)

    def GetFixPeriodicDegeneratedMode(self) -> "Standard_Integer":
        r"""GetFixPeriodicDegeneratedMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetFixPeriodicDegeneratedMode(self)

    def SetFixPeriodicDegeneratedMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixPeriodicDegeneratedMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetFixPeriodicDegeneratedMode(self, value)

    def FixSmallAreaWire(self, *args) -> "Standard_Boolean":
        r"""
        Detects wires with small area (that is less than 100*precision::pconfusion(). removes these wires if they are internal. returns : true if at least one small wire removed, false if does nothing.

        Parameters
        ----------
        theIsRemoveSmallFace: bool

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_FixSmallAreaWire(self, *args)

    def GetFixSmallAreaWireMode(self) -> "Standard_Integer":
        r"""GetFixSmallAreaWireMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetFixSmallAreaWireMode(self)

    def SetFixSmallAreaWireMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixSmallAreaWireMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetFixSmallAreaWireMode(self, value)

    def FixSplitFace(self, *args) -> "Standard_Boolean":
        r"""
        Split face if there are more than one out wire using inrormation after fixorientation().

        Parameters
        ----------
        MapWires: TopTools_DataMapOfShapeListOfShape

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_FixSplitFace(self, *args)

    def GetFixSplitFaceMode(self) -> "Standard_Integer":
        r"""GetFixSplitFaceMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetFixSplitFaceMode(self)

    def SetFixSplitFaceMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixSplitFaceMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetFixSplitFaceMode(self, value)

    def GetFixWireMode(self) -> "Standard_Integer":
        r"""GetFixWireMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetFixWireMode(self)

    def SetFixWireMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixWireMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetFixWireMode(self, value)

    def FixWireTool(self, *args) -> "opencascade::handle< ShapeFix_Wire >":
        r"""
        Returns tool for fixing wires.

        Returns
        -------
        opencascade::handle<ShapeFix_Wire>

        """
        return _ShapeFix.ShapeFix_Face_FixWireTool(self, *args)

    def FixWiresTwoCoincEdges(self, *args) -> "Standard_Boolean":
        r"""
        If wire contains two coincidence edges it must be removed queries on status after perform().

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_FixWiresTwoCoincEdges(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Loads a whole face already created, with its wires, sense and location.

        Parameters
        ----------
        face: TopoDS_Face

        Returns
        -------
        None
        Starts the creation of the face by default it will be forward, or reversed if <fwd> is false.

        Parameters
        ----------
        surf: Geom_Surface
        preci: float
        fwd: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Starts the creation of the face by default it will be forward, or reversed if <fwd> is false.

        Parameters
        ----------
        surf: ShapeAnalysis_Surface
        preci: float
        fwd: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Face_Init(self, *args)

    def Perform(self, *args) -> "Standard_Boolean":
        r"""
        Performs all the fixes, depending on modes function status returns the status of last call to perform() shapeextend_ok : face was ok, nothing done shapeextend_done1: some wires are fixed shapeextend_done2: orientation of wires fixed shapeextend_done3: missing seam added shapeextend_done4: small area wire removed shapeextend_done5: natural bounds added shapeextend_fail1: some fails during fixing wires shapeextend_fail2: cannot fix orientation of wires shapeextend_fail3: cannot add missing seam shapeextend_fail4: cannot remove small area wire.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_Perform(self, *args)

    def GetRemoveSmallAreaFaceMode(self) -> "Standard_Integer":
        r"""GetRemoveSmallAreaFaceMode(ShapeFix_Face self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Face_GetRemoveSmallAreaFaceMode(self)

    def SetRemoveSmallAreaFaceMode(self, value: "Standard_Integer") -> "void":
        r"""SetRemoveSmallAreaFaceMode(ShapeFix_Face self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Face_SetRemoveSmallAreaFaceMode(self, value)

    def Result(self, *args) -> "TopoDS_Shape":
        r"""
        Returns resulting shape (face or shell if splitted) to be used instead of face() if fixmissingseam involved.

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_Face_Result(self, *args)

    def Status(self, *args) -> "Standard_Boolean":
        r"""
        Returns the status of last call to perform() shapeextend_ok : face was ok, nothing done shapeextend_done1: some wires are fixed shapeextend_done2: orientation of wires fixed shapeextend_done3: missing seam added shapeextend_done4: small area wire removed shapeextend_done5: natural bounds added shapeextend_done8: face may be splited shapeextend_fail1: some fails during fixing wires shapeextend_fail2: cannot fix orientation of wires shapeextend_fail3: cannot add missing seam shapeextend_fail4: cannot remove small area wire.

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Face_Status(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_Face

# Register ShapeFix_Face in _ShapeFix:
_ShapeFix.ShapeFix_Face_swigregister(ShapeFix_Face)

class ShapeFix_FixSmallFace(ShapeFix_Root):
    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

        """
        _ShapeFix.ShapeFix_FixSmallFace_swiginit(self, _ShapeFix.new_ShapeFix_FixSmallFace(*args))

    def ComputeSharedEdgeForStripFace(self, *args) -> "TopoDS_Edge":
        r"""
        Compute average edge for strip face.

        Parameters
        ----------
        F: TopoDS_Face
        E1: TopoDS_Edge
        E2: TopoDS_Edge
        F1: TopoDS_Face
        tol: float

        Returns
        -------
        TopoDS_Edge

        """
        return _ShapeFix.ShapeFix_FixSmallFace_ComputeSharedEdgeForStripFace(self, *args)

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

        Parameters
        ----------
        F: TopoDS_Face

        Returns
        -------
        TopoDS_Face

        """
        return _ShapeFix.ShapeFix_FixSmallFace_FixFace(self, *args)

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

        Parameters
        ----------
        F: TopoDS_Face

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_FixSmallFace_FixPinFace(self, *args)

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

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_FixSmallFace_FixShape(self, *args)

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

        Parameters
        ----------
        S: TopoDS_Shape

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_FixSmallFace_FixSplitFace(self, *args)

    def FixSpotFace(self, *args) -> "TopoDS_Shape":
        r"""
        Fixing case of spot face, if tol = -1 used local tolerance.

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_FixSmallFace_FixSpotFace(self, *args)

    def FixStripFace(self, *args) -> "TopoDS_Shape":
        r"""
        Fixing case of strip face, if tol = -1 used local tolerance.

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

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_FixSmallFace_FixStripFace(self, *args)

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

        Parameters
        ----------
        S: TopoDS_Shape

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_FixSmallFace_Init(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Fixing case of spot face.

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_FixSmallFace_Perform(self, *args)

    def RemoveFacesInCaseOfSpot(self, *args) -> "Standard_Boolean":
        r"""
        Remove spot face from compound.

        Parameters
        ----------
        F: TopoDS_Face

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_FixSmallFace_RemoveFacesInCaseOfSpot(self, *args)

    def RemoveFacesInCaseOfStrip(self, *args) -> "Standard_Boolean":
        r"""
        Remove strip face from compound.

        Parameters
        ----------
        F: TopoDS_Face

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_FixSmallFace_RemoveFacesInCaseOfStrip(self, *args)

    def ReplaceInCaseOfStrip(self, *args) -> "Standard_Boolean":
        r"""
        Replace veretces and edges.

        Parameters
        ----------
        F: TopoDS_Face
        E1: TopoDS_Edge
        E2: TopoDS_Edge
        tol: float

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_FixSmallFace_ReplaceInCaseOfStrip(self, *args)

    def ReplaceVerticesInCaseOfSpot(self, *args) -> "Standard_Boolean":
        r"""
        Compute average vertex and replacing vertices by new one.

        Parameters
        ----------
        F: TopoDS_Face
        tol: float

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_FixSmallFace_ReplaceVerticesInCaseOfSpot(self, *args)

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

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_FixSmallFace_Shape(self, *args)

    def SplitOneFace(self, *args) -> "Standard_Boolean":
        r"""
        Compute data for face splitting.

        Parameters
        ----------
        F: TopoDS_Face
        theSplittedFaces: TopoDS_Compound

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_FixSmallFace_SplitOneFace(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_FixSmallFace

# Register ShapeFix_FixSmallFace in _ShapeFix:
_ShapeFix.ShapeFix_FixSmallFace_swigregister(ShapeFix_FixSmallFace)

class ShapeFix_FixSmallSolid(ShapeFix_Root):
    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"""
        Construct.

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_FixSmallSolid_swiginit(self, _ShapeFix.new_ShapeFix_FixSmallSolid(*args))

    def Merge(self, *args) -> "TopoDS_Shape":
        r"""
        Merge small solids in the given shape to adjacent non-small ones.

        Parameters
        ----------
        theShape: TopoDS_Shape
        theContext: ShapeBuild_ReShape

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_FixSmallSolid_Merge(self, *args)

    def Remove(self, *args) -> "TopoDS_Shape":
        r"""
        Remove small solids from the given shape.

        Parameters
        ----------
        theShape: TopoDS_Shape
        theContext: ShapeBuild_ReShape

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_FixSmallSolid_Remove(self, *args)

    def SetFixMode(self, *args) -> "void":
        r"""
        Set working mode for operator: - themode = 0 use both widthfactorthreshold and volumethreshold parameters - themode = 1 use only widthfactorthreshold parameter - themode = 2 use only volumethreshold parameter.

        Parameters
        ----------
        theMode: int

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_FixSmallSolid_SetFixMode(self, *args)

    def SetVolumeThreshold(self, *args) -> "void":
        r"""
        Set or clear volume threshold for small solids.

        Parameters
        ----------
        theThreshold: float,optional
        	default value is -1.0

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_FixSmallSolid_SetVolumeThreshold(self, *args)

    def SetWidthFactorThreshold(self, *args) -> "void":
        r"""
        Set or clear width factor threshold for small solids.

        Parameters
        ----------
        theThreshold: float,optional
        	default value is -1.0

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_FixSmallSolid_SetWidthFactorThreshold(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_FixSmallSolid

# Register ShapeFix_FixSmallSolid in _ShapeFix:
_ShapeFix.ShapeFix_FixSmallSolid_swigregister(ShapeFix_FixSmallSolid)

class ShapeFix_Shape(ShapeFix_Root):
    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
        Initislises by shape.

        Parameters
        ----------
        shape: TopoDS_Shape

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_Shape_swiginit(self, _ShapeFix.new_ShapeFix_Shape(*args))

    def FixEdgeTool(self, *args) -> "opencascade::handle< ShapeFix_Edge >":
        r"""
        Returns tool for fixing edges.

        Returns
        -------
        opencascade::handle<ShapeFix_Edge>

        """
        return _ShapeFix.ShapeFix_Shape_FixEdgeTool(self, *args)

    def FixFaceTool(self, *args) -> "opencascade::handle< ShapeFix_Face >":
        r"""
        Returns tool for fixing faces.

        Returns
        -------
        opencascade::handle<ShapeFix_Face>

        """
        return _ShapeFix.ShapeFix_Shape_FixFaceTool(self, *args)

    def GetFixFreeFaceMode(self) -> "Standard_Integer":
        r"""GetFixFreeFaceMode(ShapeFix_Shape self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Shape_GetFixFreeFaceMode(self)

    def SetFixFreeFaceMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixFreeFaceMode(ShapeFix_Shape self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Shape_SetFixFreeFaceMode(self, value)

    def GetFixFreeShellMode(self) -> "Standard_Integer":
        r"""GetFixFreeShellMode(ShapeFix_Shape self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Shape_GetFixFreeShellMode(self)

    def SetFixFreeShellMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixFreeShellMode(ShapeFix_Shape self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Shape_SetFixFreeShellMode(self, value)

    def GetFixFreeWireMode(self) -> "Standard_Integer":
        r"""GetFixFreeWireMode(ShapeFix_Shape self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Shape_GetFixFreeWireMode(self)

    def SetFixFreeWireMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixFreeWireMode(ShapeFix_Shape self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Shape_SetFixFreeWireMode(self, value)

    def GetFixSameParameterMode(self) -> "Standard_Integer":
        r"""GetFixSameParameterMode(ShapeFix_Shape self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Shape_GetFixSameParameterMode(self)

    def SetFixSameParameterMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixSameParameterMode(ShapeFix_Shape self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Shape_SetFixSameParameterMode(self, value)

    def FixShellTool(self, *args) -> "opencascade::handle< ShapeFix_Shell >":
        r"""
        Returns tool for fixing shells.

        Returns
        -------
        opencascade::handle<ShapeFix_Shell>

        """
        return _ShapeFix.ShapeFix_Shape_FixShellTool(self, *args)

    def GetFixSolidMode(self) -> "Standard_Integer":
        r"""GetFixSolidMode(ShapeFix_Shape self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Shape_GetFixSolidMode(self)

    def SetFixSolidMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixSolidMode(ShapeFix_Shape self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Shape_SetFixSolidMode(self, value)

    def FixSolidTool(self, *args) -> "opencascade::handle< ShapeFix_Solid >":
        r"""
        Returns tool for fixing solids.

        Returns
        -------
        opencascade::handle<ShapeFix_Solid>

        """
        return _ShapeFix.ShapeFix_Shape_FixSolidTool(self, *args)

    def GetFixVertexPositionMode(self) -> "Standard_Integer":
        r"""GetFixVertexPositionMode(ShapeFix_Shape self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Shape_GetFixVertexPositionMode(self)

    def SetFixVertexPositionMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixVertexPositionMode(ShapeFix_Shape self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Shape_SetFixVertexPositionMode(self, value)

    def GetFixVertexTolMode(self) -> "Standard_Integer":
        r"""GetFixVertexTolMode(ShapeFix_Shape self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Shape_GetFixVertexTolMode(self)

    def SetFixVertexTolMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixVertexTolMode(ShapeFix_Shape self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Shape_SetFixVertexTolMode(self, value)

    def FixWireTool(self, *args) -> "opencascade::handle< ShapeFix_Wire >":
        r"""
        Returns tool for fixing wires.

        Returns
        -------
        opencascade::handle<ShapeFix_Wire>

        """
        return _ShapeFix.ShapeFix_Shape_FixWireTool(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Initislises by shape.

        Parameters
        ----------
        shape: TopoDS_Shape

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Shape_Init(self, *args)

    def Perform(self, *args) -> "Standard_Boolean":
        r"""
        Iterates on sub- shape and performs fixes.

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

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Shape_Perform(self, *args)

    def Shape(self, *args) -> "TopoDS_Shape":
        r"""
        Returns resulting shape.

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_Shape_Shape(self, *args)

    def Status(self, *args) -> "Standard_Boolean":
        r"""
        Returns the status of the last fix. this can be a combination of the following flags: shapeextend_done1: some free edges were fixed shapeextend_done2: some free wires were fixed shapeextend_done3: some free faces were fixed shapeextend_done4: some free shells were fixed shapeextend_done5: some free solids were fixed shapeextend_done6: shapes in compound(s) were fixed.

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Shape_Status(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_Shape

# Register ShapeFix_Shape in _ShapeFix:
_ShapeFix.ShapeFix_Shape_swigregister(ShapeFix_Shape)

class ShapeFix_Shell(ShapeFix_Root):
    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
        Initializes by shell.

        Parameters
        ----------
        shape: TopoDS_Shell

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_Shell_swiginit(self, _ShapeFix.new_ShapeFix_Shell(*args))

    def ErrorFaces(self, *args) -> "TopoDS_Compound":
        r"""
        Returns not oriented subset of faces.

        Returns
        -------
        TopoDS_Compound

        """
        return _ShapeFix.ShapeFix_Shell_ErrorFaces(self, *args)

    def GetFixFaceMode(self) -> "Standard_Integer":
        r"""GetFixFaceMode(ShapeFix_Shell self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Shell_GetFixFaceMode(self)

    def SetFixFaceMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixFaceMode(ShapeFix_Shell self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Shell_SetFixFaceMode(self, value)

    def FixFaceOrientation(self, *args) -> "Standard_Boolean":
        r"""
        Fixes orientation of faces in shell. changes orientation of face in the shell, if it is oriented opposite to neigbouring faces. if it is not possible to orient all faces in the shell (like in case of mebious band), this method orients only subset of faces. other faces are stored in error compound. modes : isaccountmulticonex - mode for account cases of multiconnexity. if this mode is equal to standard_true, separate shells will be created in the cases of multiconnexity. if this mode is equal to standard_false, one shell will be created without account of multiconnexity.by defautt - standard_true; nonmanifold - mode for creation of non-manifold shells. if this mode is equal to standard_true one non-manifold will be created from shell contains multishared edges. else if this mode is equal to standard_false only manifold shells will be created. by default - standard_false.

        Parameters
        ----------
        shell: TopoDS_Shell
        isAccountMultiConex: bool,optional
        	default value is Standard_True
        NonManifold: bool,optional
        	default value is Standard_False

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Shell_FixFaceOrientation(self, *args)

    def FixFaceTool(self, *args) -> "opencascade::handle< ShapeFix_Face >":
        r"""
        Returns tool for fixing faces.

        Returns
        -------
        opencascade::handle<ShapeFix_Face>

        """
        return _ShapeFix.ShapeFix_Shell_FixFaceTool(self, *args)

    def GetFixOrientationMode(self) -> "Standard_Integer":
        r"""GetFixOrientationMode(ShapeFix_Shell self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Shell_GetFixOrientationMode(self)

    def SetFixOrientationMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixOrientationMode(ShapeFix_Shell self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Shell_SetFixOrientationMode(self, value)

    def Init(self, *args) -> "void":
        r"""
        Initializes by shell.

        Parameters
        ----------
        shell: TopoDS_Shell

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Shell_Init(self, *args)

    def NbShells(self, *args) -> "Standard_Integer":
        r"""
        Returns number of obtainrd shells;.

        Returns
        -------
        int

        """
        return _ShapeFix.ShapeFix_Shell_NbShells(self, *args)

    def Perform(self, *args) -> "Standard_Boolean":
        r"""
        Iterates on subshapes and performs fixes (for each face calls shapefix_face::perform and then calls fixfaceorientation). the passed progress indicator allows user to consult the current progress stage and abort algorithm if needed.

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

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Shell_Perform(self, *args)

    def SetNonManifoldFlag(self, *args) -> "void":
        r"""
        Sets nonmanifold flag.

        Parameters
        ----------
        isNonManifold: bool

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Shell_SetNonManifoldFlag(self, *args)

    def Shape(self, *args) -> "TopoDS_Shape":
        r"""
        In case of multiconnexity returns compound of fixed shells else returns one shell..

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_Shell_Shape(self, *args)

    def Shell(self, *args) -> "TopoDS_Shell":
        r"""
        Returns fixed shell (or subset of oriented faces).

        Returns
        -------
        TopoDS_Shell

        """
        return _ShapeFix.ShapeFix_Shell_Shell(self, *args)

    def Status(self, *args) -> "Standard_Boolean":
        r"""
        Returns the status of the last fix.

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Shell_Status(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_Shell

# Register ShapeFix_Shell in _ShapeFix:
_ShapeFix.ShapeFix_Shell_swigregister(ShapeFix_Shell)

class ShapeFix_Solid(ShapeFix_Root):
    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
        Initializes by solid.

        Parameters
        ----------
        solid: TopoDS_Solid

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_Solid_swiginit(self, _ShapeFix.new_ShapeFix_Solid(*args))

    def GetCreateOpenSolidMode(self) -> "Standard_Boolean":
        r"""GetCreateOpenSolidMode(ShapeFix_Solid self) -> Standard_Boolean"""
        return _ShapeFix.ShapeFix_Solid_GetCreateOpenSolidMode(self)

    def SetCreateOpenSolidMode(self, value: "Standard_Boolean") -> "void":
        r"""SetCreateOpenSolidMode(ShapeFix_Solid self, Standard_Boolean value)"""
        return _ShapeFix.ShapeFix_Solid_SetCreateOpenSolidMode(self, value)

    def GetFixShellMode(self) -> "Standard_Integer":
        r"""GetFixShellMode(ShapeFix_Solid self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Solid_GetFixShellMode(self)

    def SetFixShellMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixShellMode(ShapeFix_Solid self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Solid_SetFixShellMode(self, value)

    def GetFixShellOrientationMode(self) -> "Standard_Integer":
        r"""GetFixShellOrientationMode(ShapeFix_Solid self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Solid_GetFixShellOrientationMode(self)

    def SetFixShellOrientationMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixShellOrientationMode(ShapeFix_Solid self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Solid_SetFixShellOrientationMode(self, value)

    def FixShellTool(self, *args) -> "opencascade::handle< ShapeFix_Shell >":
        r"""
        Returns tool for fixing shells.

        Returns
        -------
        opencascade::handle<ShapeFix_Shell>

        """
        return _ShapeFix.ShapeFix_Solid_FixShellTool(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Initializes by solid .

        Parameters
        ----------
        solid: TopoDS_Solid

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Solid_Init(self, *args)

    def Perform(self, *args) -> "Standard_Boolean":
        r"""
        Iterates on shells and performs fixes (calls shapefix_shell for each subshell). the passed progress indicator allows user to consult the current progress stage and abort algorithm if needed.

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

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Solid_Perform(self, *args)

    def Shape(self, *args) -> "TopoDS_Shape":
        r"""
        In case of multiconnexity returns compound of fixed solids else returns one solid.

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_Solid_Shape(self, *args)

    def Solid(self, *args) -> "TopoDS_Shape":
        r"""
        Returns resulting solid.

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_Solid_Solid(self, *args)

    def SolidFromShell(self, *args) -> "TopoDS_Solid":
        r"""
        Calls makesolid and orients the solid to be 'not infinite'.

        Parameters
        ----------
        shell: TopoDS_Shell

        Returns
        -------
        TopoDS_Solid

        """
        return _ShapeFix.ShapeFix_Solid_SolidFromShell(self, *args)

    def Status(self, *args) -> "Standard_Boolean":
        r"""
        Returns the status of the last fix.

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Solid_Status(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_Solid

# Register ShapeFix_Solid in _ShapeFix:
_ShapeFix.ShapeFix_Solid_swigregister(ShapeFix_Solid)

class ShapeFix_SplitCommonVertex(ShapeFix_Root):
    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

        """
        _ShapeFix.ShapeFix_SplitCommonVertex_swiginit(self, _ShapeFix.new_ShapeFix_SplitCommonVertex(*args))

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

        Parameters
        ----------
        S: TopoDS_Shape

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_SplitCommonVertex_Init(self, *args)

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

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_SplitCommonVertex_Perform(self, *args)

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

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_SplitCommonVertex_Shape(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_SplitCommonVertex

# Register ShapeFix_SplitCommonVertex in _ShapeFix:
_ShapeFix.ShapeFix_SplitCommonVertex_swigregister(ShapeFix_SplitCommonVertex)

class ShapeFix_Wire(ShapeFix_Root):
    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, creates clear object with default flags.

        Returns
        -------
        None
        Create new object with default flags and prepare it for use (loads analyzer with all the data for the wire and face).

        Parameters
        ----------
        wire: TopoDS_Wire
        face: TopoDS_Face
        prec: float

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_Wire_swiginit(self, _ShapeFix.new_ShapeFix_Wire(*args))

    def Analyzer(self, *args) -> "opencascade::handle< ShapeAnalysis_Wire >":
        r"""
        Returns field analyzer (working tool).

        Returns
        -------
        opencascade::handle<ShapeAnalysis_Wire>

        """
        return _ShapeFix.ShapeFix_Wire_Analyzer(self, *args)

    def ClearModes(self, *args) -> "void":
        r"""
        Sets all modes to default.

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wire_ClearModes(self, *args)

    def ClearStatuses(self, *args) -> "void":
        r"""
        Clears all statuses.

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wire_ClearStatuses(self, *args)

    def GetClosedWireMode(self) -> "Standard_Boolean":
        r"""GetClosedWireMode(ShapeFix_Wire self) -> Standard_Boolean"""
        return _ShapeFix.ShapeFix_Wire_GetClosedWireMode(self)

    def SetClosedWireMode(self, value: "Standard_Boolean") -> "void":
        r"""SetClosedWireMode(ShapeFix_Wire self, Standard_Boolean value)"""
        return _ShapeFix.ShapeFix_Wire_SetClosedWireMode(self, value)

    def Face(self, *args) -> "TopoDS_Face const":
        r"""
        Returns working face (analyzer.face()).

        Returns
        -------
        TopoDS_Face

        """
        return _ShapeFix.ShapeFix_Wire_Face(self, *args)

    def GetFixAddCurve3dMode(self) -> "Standard_Integer":
        r"""GetFixAddCurve3dMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixAddCurve3dMode(self)

    def SetFixAddCurve3dMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixAddCurve3dMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixAddCurve3dMode(self, value)

    def GetFixAddPCurveMode(self) -> "Standard_Integer":
        r"""GetFixAddPCurveMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixAddPCurveMode(self)

    def SetFixAddPCurveMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixAddPCurveMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixAddPCurveMode(self, value)

    def FixClosed(self, *args) -> "Standard_Boolean":
        r"""
        Fixes a wire to be well closed it performs fixconnected, fixdegenerated and fixlacking between last and first edges (independingly on flag closedmode and modes for these fixings) if <prec> is -1 then maxtolerance() is taken.

        Parameters
        ----------
        prec: float,optional
        	default value is -1.0

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixClosed(self, *args)

    def FixConnected(self, *args) -> "Standard_Boolean":
        r"""
        Applies fixconnected(num) to all edges in the wire connection between first and last edges is treated only if flag closedmode is true if <prec> is -1 then maxtolerance() is taken.

        Parameters
        ----------
        prec: float,optional
        	default value is -1.0

        Returns
        -------
        bool
        Fixes connected edges (preceeding and current) forces vertices (end of preceeding-begin of current) to be the same one tests with starting preci or, if given greater, <prec> if <prec> is -1 then maxtolerance() is taken.

        Parameters
        ----------
        num: int
        prec: float

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixConnected(self, *args)

    def GetFixConnectedMode(self) -> "Standard_Integer":
        r"""GetFixConnectedMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixConnectedMode(self)

    def SetFixConnectedMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixConnectedMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixConnectedMode(self, value)

    def FixDegenerated(self, *args) -> "Standard_Boolean":
        r"""
        Applies fixdegenerated(num) to all edges in the wire connection between first and last edges is treated only if flag closedmode is true.

        Returns
        -------
        bool
        Fixes degenerated edge checks an <num-th> edge or a point between <num>th-1 and <num>th edges for a singularity on a supporting surface. if singularity is detected, either adds new degenerated edge (before <num>th), or makes <num>th edge to be degenerated.

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

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixDegenerated(self, *args)

    def GetFixDegeneratedMode(self) -> "Standard_Integer":
        r"""GetFixDegeneratedMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixDegeneratedMode(self)

    def SetFixDegeneratedMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixDegeneratedMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixDegeneratedMode(self, value)

    def FixEdgeCurves(self, *args) -> "Standard_Boolean":
        r"""
        Groups the fixes dealing with 3d and pcurves of the edges. the order of the fixes and the default behaviour are: shapefix_edge::fixreversed2d shapefix_edge::fixremovepcurve (only if forced) shapefix_edge::fixaddpcurve shapefix_edge::fixremovecurve3d (only if forced) shapefix_edge::fixaddcurve3d fixseam, fixshifted, shapefix_edge::fixsameparameter.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixEdgeCurves(self, *args)

    def GetFixEdgeCurvesMode(self) -> "Standard_Integer":
        r"""GetFixEdgeCurvesMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixEdgeCurvesMode(self)

    def SetFixEdgeCurvesMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixEdgeCurvesMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixEdgeCurvesMode(self, value)

    def FixEdgeTool(self, *args) -> "opencascade::handle< ShapeFix_Edge >":
        r"""
        Returns tool for fixing wires.

        Returns
        -------
        opencascade::handle<ShapeFix_Edge>

        """
        return _ShapeFix.ShapeFix_Wire_FixEdgeTool(self, *args)

    def FixGap2d(self, *args) -> "Standard_Boolean":
        r"""
        Fixes gap between ends of pcurves on num-1 and num-th edges. myprecision is used to detect the gap. if convert is true, converts pcurves to bsplines to bend.

        Parameters
        ----------
        num: int
        convert: bool,optional
        	default value is Standard_False

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixGap2d(self, *args)

    def FixGap3d(self, *args) -> "Standard_Boolean":
        r"""
        Fixes gap between ends of 3d curves on num-1 and num-th edges. myprecision is used to detect the gap. if convert is true, converts curves to bsplines to bend.

        Parameters
        ----------
        num: int
        convert: bool,optional
        	default value is Standard_False

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixGap3d(self, *args)

    def FixGaps2d(self, *args) -> "Standard_Boolean":
        r"""
        Fixes gaps between ends of pcurves on adjacent edges myprecision is used to detect the gaps.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixGaps2d(self, *args)

    def GetFixGaps2dMode(self) -> "Standard_Integer":
        r"""GetFixGaps2dMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixGaps2dMode(self)

    def SetFixGaps2dMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixGaps2dMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixGaps2dMode(self, value)

    def FixGaps3d(self, *args) -> "Standard_Boolean":
        r"""
        Fixes gaps between ends of 3d curves on adjacent edges myprecision is used to detect the gaps.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixGaps3d(self, *args)

    def GetFixGaps3dMode(self) -> "Standard_Integer":
        r"""GetFixGaps3dMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixGaps3dMode(self)

    def SetFixGaps3dMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixGaps3dMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixGaps3dMode(self, value)

    def GetFixGapsByRangesMode(self) -> "Standard_Boolean":
        r"""GetFixGapsByRangesMode(ShapeFix_Wire self) -> Standard_Boolean"""
        return _ShapeFix.ShapeFix_Wire_GetFixGapsByRangesMode(self)

    def SetFixGapsByRangesMode(self, value: "Standard_Boolean") -> "void":
        r"""SetFixGapsByRangesMode(ShapeFix_Wire self, Standard_Boolean value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixGapsByRangesMode(self, value)

    def GetFixIntersectingEdgesMode(self) -> "Standard_Integer":
        r"""GetFixIntersectingEdgesMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixIntersectingEdgesMode(self)

    def SetFixIntersectingEdgesMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixIntersectingEdgesMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixIntersectingEdgesMode(self, value)

    def FixLacking(self, *args) -> "Standard_Boolean":
        r"""
        Applies fixlacking(num) to all edges in the wire connection between first and last edges is treated only if flag closedmode is true if <force> is false (default), test for connectness is done with precision of vertex between edges, else it is done with minimal value of vertex tolerance and analyzer.precision(). hence, <force> will lead to inserting lacking edges in replacement of vertices which have big tolerances.

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

        Returns
        -------
        bool
        Fixes lacking edge test if two adjucent edges are disconnected in 2d (while connected in 3d), and in that case either increase tolerance of the vertex or add a new edge (straight in 2d space), in order to close wire in 2d. returns true if edge was added or tolerance was increased.

        Parameters
        ----------
        num: int
        force: bool,optional
        	default value is Standard_False

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixLacking(self, *args)

    def GetFixLackingMode(self) -> "Standard_Integer":
        r"""GetFixLackingMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixLackingMode(self)

    def SetFixLackingMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixLackingMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixLackingMode(self, value)

    def GetFixNonAdjacentIntersectingEdgesMode(self) -> "Standard_Integer":
        r"""GetFixNonAdjacentIntersectingEdgesMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixNonAdjacentIntersectingEdgesMode(self)

    def SetFixNonAdjacentIntersectingEdgesMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixNonAdjacentIntersectingEdgesMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixNonAdjacentIntersectingEdgesMode(self, value)

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

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixNotchedEdges(self, *args)

    def GetFixNotchedEdgesMode(self) -> "Standard_Integer":
        r"""GetFixNotchedEdgesMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixNotchedEdgesMode(self)

    def SetFixNotchedEdgesMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixNotchedEdgesMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixNotchedEdgesMode(self, value)

    def GetFixRemoveCurve3dMode(self) -> "Standard_Integer":
        r"""GetFixRemoveCurve3dMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixRemoveCurve3dMode(self)

    def SetFixRemoveCurve3dMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixRemoveCurve3dMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixRemoveCurve3dMode(self, value)

    def GetFixRemovePCurveMode(self) -> "Standard_Integer":
        r"""GetFixRemovePCurveMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixRemovePCurveMode(self)

    def SetFixRemovePCurveMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixRemovePCurveMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixRemovePCurveMode(self, value)

    def FixReorder(self, *args) -> "Standard_Boolean":
        r"""
        Performs an analysis and reorders edges in the wire using class wireorder.

        Returns
        -------
        bool
        Reorder edges in the wire as determined by wireorder that should be filled and computed before.

        Parameters
        ----------
        wi: ShapeAnalysis_WireOrder

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixReorder(self, *args)

    def GetFixReorderMode(self) -> "Standard_Integer":
        r"""GetFixReorderMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixReorderMode(self)

    def SetFixReorderMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixReorderMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixReorderMode(self, value)

    def GetFixReversed2dMode(self) -> "Standard_Integer":
        r"""GetFixReversed2dMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixReversed2dMode(self)

    def SetFixReversed2dMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixReversed2dMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixReversed2dMode(self, value)

    def GetFixSameParameterMode(self) -> "Standard_Integer":
        r"""GetFixSameParameterMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixSameParameterMode(self)

    def SetFixSameParameterMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixSameParameterMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixSameParameterMode(self, value)

    def FixSeam(self, *args) -> "Standard_Boolean":
        r"""
        Fixes a seam edge a seam edge has two pcurves, one for forward. one for reversed the forward pcurve must be set as first //! note that correct order of pcurves in the seam edge depends on its orientation (i.e., on orientation of the wire, method of exploration of edges etc.). since wire represented by the shapeextend_wiredata is always forward (orientation is accounted by edges), it will work correct if: 1. wire created from shapeextend_wiredata with methods shapeextend_wiredata::wire..() is added into the forward face (orientation can be applied later) 2. wire is extracted from the face with orientation not composed with orientation of the face.

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

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixSeam(self, *args)

    def GetFixSeamMode(self) -> "Standard_Integer":
        r"""GetFixSeamMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixSeamMode(self)

    def SetFixSeamMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixSeamMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixSeamMode(self, value)

    def GetFixSelfIntersectingEdgeMode(self) -> "Standard_Integer":
        r"""GetFixSelfIntersectingEdgeMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixSelfIntersectingEdgeMode(self)

    def SetFixSelfIntersectingEdgeMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixSelfIntersectingEdgeMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixSelfIntersectingEdgeMode(self, value)

    def FixSelfIntersection(self, *args) -> "Standard_Boolean":
        r"""
        Applies fixselfintersectingedge(num) and fixintersectingedges(num) to all edges in the wire and fixintersectingedges(num1, num2) for all pairs num1 and num2 such that num2 >= num1 + 2 and removes wrong edges if any.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixSelfIntersection(self, *args)

    def GetFixSelfIntersectionMode(self) -> "Standard_Integer":
        r"""GetFixSelfIntersectionMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixSelfIntersectionMode(self)

    def SetFixSelfIntersectionMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixSelfIntersectionMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixSelfIntersectionMode(self, value)

    def FixShifted(self, *args) -> "Standard_Boolean":
        r"""
        Fixes edges which have pcurves shifted by whole parameter range on the closed surface (the case may occur if pcurve of edge was computed by projecting 3d curve, which goes along the seam). it compares each two consequent edges and tries to connect them if distance between ends is near to range of the surface. it also can detect and fix the case if all pcurves are connected, but lie out of parametric bounds of the surface. in addition to fixshifted from shapefix_wire, more sophisticated check of degenerate points is performed, and special cases like sphere given by two meridians are treated.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixShifted(self, *args)

    def GetFixShiftedMode(self) -> "Standard_Integer":
        r"""GetFixShiftedMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixShiftedMode(self)

    def SetFixShiftedMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixShiftedMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixShiftedMode(self, value)

    def FixSmall(self, *args) -> "Standard_Boolean":
        r"""
        Applies fixsmall(num) to all edges in the wire.

        Parameters
        ----------
        lockvtx: bool
        precsmall: float,optional
        	default value is 0.0

        Returns
        -------
        int
        Fixes null length edge to be removed if an edge has null length (regarding preci, or <precsmall> - what is smaller), it should be removed it can be with no problem if its two vertices are the same else, if lockvtx is false, it is removed and its end vertex is put on the preceeding edge but if lockvtx is true, this edge must be kept ...

        Parameters
        ----------
        num: int
        lockvtx: bool
        precsmall: float

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixSmall(self, *args)

    def GetFixSmallMode(self) -> "Standard_Integer":
        r"""GetFixSmallMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixSmallMode(self)

    def SetFixSmallMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixSmallMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixSmallMode(self, value)

    def GetFixTailMode(self) -> "Standard_Integer":
        r"""GetFixTailMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixTailMode(self)

    def SetFixTailMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixTailMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixTailMode(self, value)

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

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_FixTails(self, *args)

    def GetFixVertexToleranceMode(self) -> "Standard_Integer":
        r"""GetFixVertexToleranceMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetFixVertexToleranceMode(self)

    def SetFixVertexToleranceMode(self, value: "Standard_Integer") -> "void":
        r"""SetFixVertexToleranceMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetFixVertexToleranceMode(self, value)

    def Init(self, *args) -> "void":
        r"""
        Load analyzer with all the data for the wire and face and drops all fixing statuses.

        Parameters
        ----------
        wire: TopoDS_Wire
        face: TopoDS_Face
        prec: float

        Returns
        -------
        None
        Load analyzer with all the data already prepared and drops all fixing statuses if analyzer contains face, there is no need to set it by setface or setsurface.

        Parameters
        ----------
        saw: ShapeAnalysis_Wire

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wire_Init(self, *args)

    def IsLoaded(self, *args) -> "Standard_Boolean":
        r"""
        Tells if the wire is loaded.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_IsLoaded(self, *args)

    def IsReady(self, *args) -> "Standard_Boolean":
        r"""
        Tells if the wire and face are loaded.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_IsReady(self, *args)

    def LastFixStatus(self, *args) -> "Standard_Boolean":
        r"""
        Queries the status of last call to methods fix... of advanced level for details see corresponding methods; universal statuses are: ok : problem not detected; nothing done done: problem was detected and successfully fixed fail: problem cannot be fixed.

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_LastFixStatus(self, *args)

    def Load(self, *args) -> "void":
        r"""
        Load data for the wire, and drops all fixing statuses.

        Parameters
        ----------
        wire: TopoDS_Wire

        Returns
        -------
        None
        Load data for the wire, and drops all fixing statuses.

        Parameters
        ----------
        sbwd: ShapeExtend_WireData

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wire_Load(self, *args)

    def GetModifyGeometryMode(self) -> "Standard_Boolean":
        r"""GetModifyGeometryMode(ShapeFix_Wire self) -> Standard_Boolean"""
        return _ShapeFix.ShapeFix_Wire_GetModifyGeometryMode(self)

    def SetModifyGeometryMode(self, value: "Standard_Boolean") -> "void":
        r"""SetModifyGeometryMode(ShapeFix_Wire self, Standard_Boolean value)"""
        return _ShapeFix.ShapeFix_Wire_SetModifyGeometryMode(self, value)

    def GetModifyRemoveLoopMode(self) -> "Standard_Integer":
        r"""GetModifyRemoveLoopMode(ShapeFix_Wire self) -> Standard_Integer"""
        return _ShapeFix.ShapeFix_Wire_GetModifyRemoveLoopMode(self)

    def SetModifyRemoveLoopMode(self, value: "Standard_Integer") -> "void":
        r"""SetModifyRemoveLoopMode(ShapeFix_Wire self, Standard_Integer value)"""
        return _ShapeFix.ShapeFix_Wire_SetModifyRemoveLoopMode(self, value)

    def GetModifyTopologyMode(self) -> "Standard_Boolean":
        r"""GetModifyTopologyMode(ShapeFix_Wire self) -> Standard_Boolean"""
        return _ShapeFix.ShapeFix_Wire_GetModifyTopologyMode(self)

    def SetModifyTopologyMode(self, value: "Standard_Boolean") -> "void":
        r"""SetModifyTopologyMode(ShapeFix_Wire self, Standard_Boolean value)"""
        return _ShapeFix.ShapeFix_Wire_SetModifyTopologyMode(self, value)

    def NbEdges(self, *args) -> "Standard_Integer":
        r"""
        Returns number of edges in the working wire.

        Returns
        -------
        int

        """
        return _ShapeFix.ShapeFix_Wire_NbEdges(self, *args)

    def Perform(self, *args) -> "Standard_Boolean":
        r"""
        This method performs all the available fixes. if some fix is turned on or off explicitly by the fix..mode() flag, this fix is either called or not depending on that flag. else (i.e. if flag is default) fix is called depending on the situation: some fixes are not called or are limited if order of edges in the wire is not ok, or depending on modes //! the order of the fixes and default behaviour of perform() are: fixreorder fixsmall (with lockvtx true if ! topomode or if wire is not ordered) fixconnected (if wire is ordered) fixedgecurves (without fixshifted if wire is not ordered) fixdegenerated (if wire is ordered) fixselfintersection (if wire is ordered and closedmode is true) fixlacking (if wire is ordered).

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_Perform(self, *args)

    def GetPreferencePCurveMode(self) -> "Standard_Boolean":
        r"""GetPreferencePCurveMode(ShapeFix_Wire self) -> Standard_Boolean"""
        return _ShapeFix.ShapeFix_Wire_GetPreferencePCurveMode(self)

    def SetPreferencePCurveMode(self, value: "Standard_Boolean") -> "void":
        r"""SetPreferencePCurveMode(ShapeFix_Wire self, Standard_Boolean value)"""
        return _ShapeFix.ShapeFix_Wire_SetPreferencePCurveMode(self, value)

    def SetFace(self, *args) -> "void":
        r"""
        Set working face for the wire.

        Parameters
        ----------
        face: TopoDS_Face

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wire_SetFace(self, *args)

    def SetMaxTailAngle(self, *args) -> "void":
        r"""
        Sets the maximal allowed angle of the tails in radians.

        Parameters
        ----------
        theMaxTailAngle: float

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wire_SetMaxTailAngle(self, *args)

    def SetMaxTailWidth(self, *args) -> "void":
        r"""
        Sets the maximal allowed width of the tails.

        Parameters
        ----------
        theMaxTailWidth: float

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wire_SetMaxTailWidth(self, *args)

    def SetSurface(self, *args) -> "void":
        r"""
        Set surface for the wire.

        Parameters
        ----------
        surf: Geom_Surface

        Returns
        -------
        None
        Set surface for the wire.

        Parameters
        ----------
        surf: Geom_Surface
        loc: TopLoc_Location

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wire_SetSurface(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusClosed(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusConnected(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusDegenerated(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusEdgeCurves(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusFixTails(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusGaps2d(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusGaps3d(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusLacking(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusNotches(self, *args)

    def StatusRemovedSegment(self, *args) -> "Standard_Boolean":
        r"""
        Querying the status of perfomed api fixing procedures each status..() methods gives information about the last call to the corresponding fix..() method of api level: ok : no problems detected; nothing done done: some problem(s) was(were) detected and successfully fixed fail: some problem(s) cannot be fixed.

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusRemovedSegment(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusReorder(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusSelfIntersection(self, *args)

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

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wire_StatusSmall(self, *args)

    def Wire(self, *args) -> "TopoDS_Wire":
        r"""
        Makes the resulting wire (by basic brep_builder).

        Returns
        -------
        TopoDS_Wire

        """
        return _ShapeFix.ShapeFix_Wire_Wire(self, *args)

    def WireAPIMake(self, *args) -> "TopoDS_Wire":
        r"""
        Makes the resulting wire (by brepapi_makewire).

        Returns
        -------
        TopoDS_Wire

        """
        return _ShapeFix.ShapeFix_Wire_WireAPIMake(self, *args)

    def WireData(self, *args) -> "opencascade::handle< ShapeExtend_WireData > const &":
        r"""
        Returns working wire.

        Returns
        -------
        opencascade::handle<ShapeExtend_WireData>

        """
        return _ShapeFix.ShapeFix_Wire_WireData(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_Wire

# Register ShapeFix_Wire in _ShapeFix:
_ShapeFix.ShapeFix_Wire_swigregister(ShapeFix_Wire)

class ShapeFix_Wireframe(ShapeFix_Root):
    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
        ----------
        shape: TopoDS_Shape

        Returns
        -------
        None

        """
        _ShapeFix.ShapeFix_Wireframe_swiginit(self, _ShapeFix.new_ShapeFix_Wireframe(*args))

    def CheckSmallEdges(self, *args) -> "Standard_Boolean":
        r"""
        Auxiliary tool for fixsmalledges which checks for small edges and fills the maps. returns true if at least one small edge has been found.

        Parameters
        ----------
        theSmallEdges: TopTools_MapOfShape
        theEdgeToFaces: TopTools_DataMapOfShapeListOfShape
        theFaceWithSmall: TopTools_DataMapOfShapeListOfShape
        theMultyEdges: TopTools_MapOfShape

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wireframe_CheckSmallEdges(self, *args)

    def ClearStatuses(self, *args) -> "void":
        r"""
        Clears all statuses.

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wireframe_ClearStatuses(self, *args)

    def FixSmallEdges(self, *args) -> "Standard_Boolean":
        r"""
        Fixes small edges in shape by merging adjacent edges if precision is 0.0, uses precision::confusion().

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wireframe_FixSmallEdges(self, *args)

    def FixWireGaps(self, *args) -> "Standard_Boolean":
        r"""
        Fixes gaps between ends of curves of adjacent edges (both 3d and pcurves) in wires if precision is 0.0, uses precision::confusion().

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wireframe_FixWireGaps(self, *args)

    def LimitAngle(self, *args) -> "Standard_Real":
        r"""
        Get limit angle for merging edges.

        Returns
        -------
        float

        """
        return _ShapeFix.ShapeFix_Wireframe_LimitAngle(self, *args)

    def Load(self, *args) -> "void":
        r"""
        Loads a shape, resets statuses.

        Parameters
        ----------
        shape: TopoDS_Shape

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wireframe_Load(self, *args)

    def MergeSmallEdges(self, *args) -> "Standard_Boolean":
        r"""
        Auxiliary tool for fixsmalledges which merges small edges. if themodedrop is equal to standard_true then small edges, which cannot be connected with adjacent edges are dropped. otherwise they are kept. thelimitangle specifies maximum allowed tangency discontinuity between adjacent edges. if thelimitangle is equal to -1, this angle is not taken into account.

        Parameters
        ----------
        theSmallEdges: TopTools_MapOfShape
        theEdgeToFaces: TopTools_DataMapOfShapeListOfShape
        theFaceWithSmall: TopTools_DataMapOfShapeListOfShape
        theMultyEdges: TopTools_MapOfShape
        theModeDrop: bool,optional
        	default value is Standard_False
        theLimitAngle: float,optional
        	default value is -1

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wireframe_MergeSmallEdges(self, *args)

    def GetModeDropSmallEdges(self) -> "Standard_Boolean":
        r"""GetModeDropSmallEdges(ShapeFix_Wireframe self) -> Standard_Boolean"""
        return _ShapeFix.ShapeFix_Wireframe_GetModeDropSmallEdges(self)

    def SetModeDropSmallEdges(self, value: "Standard_Boolean") -> "void":
        r"""SetModeDropSmallEdges(ShapeFix_Wireframe self, Standard_Boolean value)"""
        return _ShapeFix.ShapeFix_Wireframe_SetModeDropSmallEdges(self, value)

    def SetLimitAngle(self, *args) -> "void":
        r"""
        Set limit angle for merging edges.

        Parameters
        ----------
        theLimitAngle: float

        Returns
        -------
        None

        """
        return _ShapeFix.ShapeFix_Wireframe_SetLimitAngle(self, *args)

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

        Returns
        -------
        TopoDS_Shape

        """
        return _ShapeFix.ShapeFix_Wireframe_Shape(self, *args)

    def StatusSmallEdges(self, *args) -> "Standard_Boolean":
        r"""
        Decodes the status of the last fixsmalledges. ok - no small edges were found done1 - some small edges were fixed fail1 - failed to fix some small edges.

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wireframe_StatusSmallEdges(self, *args)

    def StatusWireGaps(self, *args) -> "Standard_Boolean":
        r"""
        Decodes the status of the last fixwiregaps. ok - no gaps were found done1 - some gaps in 3d were fixed done2 - some gaps in 2d were fixed fail1 - failed to fix some gaps in 3d fail2 - failed to fix some gaps in 2d.

        Parameters
        ----------
        status: ShapeExtend_Status

        Returns
        -------
        bool

        """
        return _ShapeFix.ShapeFix_Wireframe_StatusWireGaps(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _ShapeFix.delete_ShapeFix_Wireframe

# Register ShapeFix_Wireframe in _ShapeFix:
_ShapeFix.ShapeFix_Wireframe_swigregister(ShapeFix_Wireframe)


@classnotwrapped
class ShapeFix_WireSegment:
	pass






