# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

"""
StepData module, see official documentation at
https://www.opencascade.com/doc/occt-7.7.0/refman/html/package_stepdata.html
"""

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _StepData
else:
    import _StepData

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 == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(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__ = _StepData.delete_SwigPyIterator

    def value(self):
        return _StepData.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _StepData.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _StepData.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _StepData.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _StepData.SwigPyIterator_equal(self, x)

    def copy(self):
        return _StepData.SwigPyIterator_copy(self)

    def next(self):
        return _StepData.SwigPyIterator_next(self)

    def __next__(self):
        return _StepData.SwigPyIterator___next__(self)

    def previous(self):
        return _StepData.SwigPyIterator_previous(self)

    def advance(self, n):
        return _StepData.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _StepData.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _StepData.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _StepData.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _StepData.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _StepData.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _StepData.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _StepData:
_StepData.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, method_name, class_name):
    return _StepData.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.Interface
import OCC.Core.TCollection
import OCC.Core.Message
import OCC.Core.OSD
import OCC.Core.TColStd
import OCC.Core.MoniTool
import OCC.Core.TopoDS
import OCC.Core.TopAbs
import OCC.Core.TopLoc
import OCC.Core.gp
import OCC.Core.Resource

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

StepData_LFalse = _StepData.StepData_LFalse
StepData_LTrue = _StepData.StepData_LTrue
StepData_LUnknown = _StepData.StepData_LUnknown


class StepData_Logical(IntEnum):
	StepData_LFalse = 0
	StepData_LTrue = 1
	StepData_LUnknown = 2
StepData_LFalse = StepData_Logical.StepData_LFalse
StepData_LTrue = StepData_Logical.StepData_LTrue
StepData_LUnknown = StepData_Logical.StepData_LUnknown


def Handle_StepData_Described_Create():
    return _StepData.Handle_StepData_Described_Create()

def Handle_StepData_Described_DownCast(t):
    return _StepData.Handle_StepData_Described_DownCast(t)

def Handle_StepData_Described_IsNull(t):
    return _StepData.Handle_StepData_Described_IsNull(t)

def Handle_StepData_EDescr_Create():
    return _StepData.Handle_StepData_EDescr_Create()

def Handle_StepData_EDescr_DownCast(t):
    return _StepData.Handle_StepData_EDescr_DownCast(t)

def Handle_StepData_EDescr_IsNull(t):
    return _StepData.Handle_StepData_EDescr_IsNull(t)

def Handle_StepData_FileRecognizer_Create():
    return _StepData.Handle_StepData_FileRecognizer_Create()

def Handle_StepData_FileRecognizer_DownCast(t):
    return _StepData.Handle_StepData_FileRecognizer_DownCast(t)

def Handle_StepData_FileRecognizer_IsNull(t):
    return _StepData.Handle_StepData_FileRecognizer_IsNull(t)

def Handle_StepData_GeneralModule_Create():
    return _StepData.Handle_StepData_GeneralModule_Create()

def Handle_StepData_GeneralModule_DownCast(t):
    return _StepData.Handle_StepData_GeneralModule_DownCast(t)

def Handle_StepData_GeneralModule_IsNull(t):
    return _StepData.Handle_StepData_GeneralModule_IsNull(t)

def Handle_StepData_GlobalNodeOfWriterLib_Create():
    return _StepData.Handle_StepData_GlobalNodeOfWriterLib_Create()

def Handle_StepData_GlobalNodeOfWriterLib_DownCast(t):
    return _StepData.Handle_StepData_GlobalNodeOfWriterLib_DownCast(t)

def Handle_StepData_GlobalNodeOfWriterLib_IsNull(t):
    return _StepData.Handle_StepData_GlobalNodeOfWriterLib_IsNull(t)

def Handle_StepData_NodeOfWriterLib_Create():
    return _StepData.Handle_StepData_NodeOfWriterLib_Create()

def Handle_StepData_NodeOfWriterLib_DownCast(t):
    return _StepData.Handle_StepData_NodeOfWriterLib_DownCast(t)

def Handle_StepData_NodeOfWriterLib_IsNull(t):
    return _StepData.Handle_StepData_NodeOfWriterLib_IsNull(t)

def Handle_StepData_PDescr_Create():
    return _StepData.Handle_StepData_PDescr_Create()

def Handle_StepData_PDescr_DownCast(t):
    return _StepData.Handle_StepData_PDescr_DownCast(t)

def Handle_StepData_PDescr_IsNull(t):
    return _StepData.Handle_StepData_PDescr_IsNull(t)

def Handle_StepData_Protocol_Create():
    return _StepData.Handle_StepData_Protocol_Create()

def Handle_StepData_Protocol_DownCast(t):
    return _StepData.Handle_StepData_Protocol_DownCast(t)

def Handle_StepData_Protocol_IsNull(t):
    return _StepData.Handle_StepData_Protocol_IsNull(t)

def Handle_StepData_ReadWriteModule_Create():
    return _StepData.Handle_StepData_ReadWriteModule_Create()

def Handle_StepData_ReadWriteModule_DownCast(t):
    return _StepData.Handle_StepData_ReadWriteModule_DownCast(t)

def Handle_StepData_ReadWriteModule_IsNull(t):
    return _StepData.Handle_StepData_ReadWriteModule_IsNull(t)

def Handle_StepData_SelectMember_Create():
    return _StepData.Handle_StepData_SelectMember_Create()

def Handle_StepData_SelectMember_DownCast(t):
    return _StepData.Handle_StepData_SelectMember_DownCast(t)

def Handle_StepData_SelectMember_IsNull(t):
    return _StepData.Handle_StepData_SelectMember_IsNull(t)

def Handle_StepData_StepModel_Create():
    return _StepData.Handle_StepData_StepModel_Create()

def Handle_StepData_StepModel_DownCast(t):
    return _StepData.Handle_StepData_StepModel_DownCast(t)

def Handle_StepData_StepModel_IsNull(t):
    return _StepData.Handle_StepData_StepModel_IsNull(t)

def Handle_StepData_StepReaderData_Create():
    return _StepData.Handle_StepData_StepReaderData_Create()

def Handle_StepData_StepReaderData_DownCast(t):
    return _StepData.Handle_StepData_StepReaderData_DownCast(t)

def Handle_StepData_StepReaderData_IsNull(t):
    return _StepData.Handle_StepData_StepReaderData_IsNull(t)

def Handle_StepData_DefaultGeneral_Create():
    return _StepData.Handle_StepData_DefaultGeneral_Create()

def Handle_StepData_DefaultGeneral_DownCast(t):
    return _StepData.Handle_StepData_DefaultGeneral_DownCast(t)

def Handle_StepData_DefaultGeneral_IsNull(t):
    return _StepData.Handle_StepData_DefaultGeneral_IsNull(t)

def Handle_StepData_ECDescr_Create():
    return _StepData.Handle_StepData_ECDescr_Create()

def Handle_StepData_ECDescr_DownCast(t):
    return _StepData.Handle_StepData_ECDescr_DownCast(t)

def Handle_StepData_ECDescr_IsNull(t):
    return _StepData.Handle_StepData_ECDescr_IsNull(t)

def Handle_StepData_ESDescr_Create():
    return _StepData.Handle_StepData_ESDescr_Create()

def Handle_StepData_ESDescr_DownCast(t):
    return _StepData.Handle_StepData_ESDescr_DownCast(t)

def Handle_StepData_ESDescr_IsNull(t):
    return _StepData.Handle_StepData_ESDescr_IsNull(t)

def Handle_StepData_FileProtocol_Create():
    return _StepData.Handle_StepData_FileProtocol_Create()

def Handle_StepData_FileProtocol_DownCast(t):
    return _StepData.Handle_StepData_FileProtocol_DownCast(t)

def Handle_StepData_FileProtocol_IsNull(t):
    return _StepData.Handle_StepData_FileProtocol_IsNull(t)

def Handle_StepData_Plex_Create():
    return _StepData.Handle_StepData_Plex_Create()

def Handle_StepData_Plex_DownCast(t):
    return _StepData.Handle_StepData_Plex_DownCast(t)

def Handle_StepData_Plex_IsNull(t):
    return _StepData.Handle_StepData_Plex_IsNull(t)

def Handle_StepData_SelectInt_Create():
    return _StepData.Handle_StepData_SelectInt_Create()

def Handle_StepData_SelectInt_DownCast(t):
    return _StepData.Handle_StepData_SelectInt_DownCast(t)

def Handle_StepData_SelectInt_IsNull(t):
    return _StepData.Handle_StepData_SelectInt_IsNull(t)

def Handle_StepData_SelectNamed_Create():
    return _StepData.Handle_StepData_SelectNamed_Create()

def Handle_StepData_SelectNamed_DownCast(t):
    return _StepData.Handle_StepData_SelectNamed_DownCast(t)

def Handle_StepData_SelectNamed_IsNull(t):
    return _StepData.Handle_StepData_SelectNamed_IsNull(t)

def Handle_StepData_SelectReal_Create():
    return _StepData.Handle_StepData_SelectReal_Create()

def Handle_StepData_SelectReal_DownCast(t):
    return _StepData.Handle_StepData_SelectReal_DownCast(t)

def Handle_StepData_SelectReal_IsNull(t):
    return _StepData.Handle_StepData_SelectReal_IsNull(t)

def Handle_StepData_Simple_Create():
    return _StepData.Handle_StepData_Simple_Create()

def Handle_StepData_Simple_DownCast(t):
    return _StepData.Handle_StepData_Simple_DownCast(t)

def Handle_StepData_Simple_IsNull(t):
    return _StepData.Handle_StepData_Simple_IsNull(t)

def Handle_StepData_SelectArrReal_Create():
    return _StepData.Handle_StepData_SelectArrReal_Create()

def Handle_StepData_SelectArrReal_DownCast(t):
    return _StepData.Handle_StepData_SelectArrReal_DownCast(t)

def Handle_StepData_SelectArrReal_IsNull(t):
    return _StepData.Handle_StepData_SelectArrReal_IsNull(t)

def Handle_StepData_HArray1OfField_Create():
    return _StepData.Handle_StepData_HArray1OfField_Create()

def Handle_StepData_HArray1OfField_DownCast(t):
    return _StepData.Handle_StepData_HArray1OfField_DownCast(t)

def Handle_StepData_HArray1OfField_IsNull(t):
    return _StepData.Handle_StepData_HArray1OfField_IsNull(t)
class StepData_Array1OfField(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):
        return _StepData.StepData_Array1OfField_begin(self)

    def end(self):
        return _StepData.StepData_Array1OfField_end(self)

    def cbegin(self):
        return _StepData.StepData_Array1OfField_cbegin(self)

    def cend(self):
        return _StepData.StepData_Array1OfField_cend(self)

    def __init__(self, *args):
        _StepData.StepData_Array1OfField_swiginit(self, _StepData.new_StepData_Array1OfField(*args))

    def Init(self, theValue):
        return _StepData.StepData_Array1OfField_Init(self, theValue)

    def Size(self):
        return _StepData.StepData_Array1OfField_Size(self)

    def Length(self):
        return _StepData.StepData_Array1OfField_Length(self)

    def IsEmpty(self):
        return _StepData.StepData_Array1OfField_IsEmpty(self)

    def Lower(self):
        return _StepData.StepData_Array1OfField_Lower(self)

    def Upper(self):
        return _StepData.StepData_Array1OfField_Upper(self)

    def IsDeletable(self):
        return _StepData.StepData_Array1OfField_IsDeletable(self)

    def IsAllocated(self):
        return _StepData.StepData_Array1OfField_IsAllocated(self)

    def Assign(self, theOther):
        return _StepData.StepData_Array1OfField_Assign(self, theOther)

    def Move(self, theOther):
        return _StepData.StepData_Array1OfField_Move(self, theOther)

    def Set(self, *args):
        return _StepData.StepData_Array1OfField_Set(self, *args)

    def First(self):
        return _StepData.StepData_Array1OfField_First(self)

    def ChangeFirst(self):
        return _StepData.StepData_Array1OfField_ChangeFirst(self)

    def Last(self):
        return _StepData.StepData_Array1OfField_Last(self)

    def ChangeLast(self):
        return _StepData.StepData_Array1OfField_ChangeLast(self)

    def Value(self, theIndex):
        return _StepData.StepData_Array1OfField_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _StepData.StepData_Array1OfField_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _StepData.StepData_Array1OfField___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _StepData.StepData_Array1OfField_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _StepData.StepData_Array1OfField_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _StepData.delete_StepData_Array1OfField

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

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

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

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

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

    __next__ = next


# Register StepData_Array1OfField in _StepData:
_StepData.StepData_Array1OfField_swigregister(StepData_Array1OfField)
class stepdata(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def AddHeaderProtocol(*args):
        r"""

        Parameters
        ----------
        headerproto: StepData_Protocol

        Return
        -------
        None

        Description
        -----------
        Adds a new header protocol to the header definition.

        """
        return _StepData.stepdata_AddHeaderProtocol(*args)

    @staticmethod
    def HeaderProtocol(*args):
        r"""
        Return
        -------
        opencascade::handle<StepData_Protocol>

        Description
        -----------
        Returns the recorded headerprotocol, which can be: - a null handle if no header protocol was yet defined - a simple protocol if only one was defined - a fileprotocol if more than one protocol was yet defined.

        """
        return _StepData.stepdata_HeaderProtocol(*args)

    @staticmethod
    def Init(*args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Prepares general data required to work with this package, which are the protocol and modules to be loaded into libraries.

        """
        return _StepData.stepdata_Init(*args)

    @staticmethod
    def Protocol(*args):
        r"""
        Return
        -------
        opencascade::handle<StepData_Protocol>

        Description
        -----------
        Returns a protocol from stepdata (avoids to create it).

        """
        return _StepData.stepdata_Protocol(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _StepData.stepdata_swiginit(self, _StepData.new_stepdata())
    __swig_destroy__ = _StepData.delete_stepdata

# Register stepdata in _StepData:
_StepData.stepdata_swigregister(stepdata)
class StepData_Described(OCC.Core.Standard.Standard_Transient):
    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")
    __repr__ = _swig_repr

    def As(self, *args):
        r"""

        Parameters
        ----------
        steptype: str

        Return
        -------
        opencascade::handle<StepData_Simple>

        Description
        -----------
        Returns a simple entity which matches with a type in <self>: for a simple entity: me if it matches, else a null handle for a complex entity: the member which matches, else null.

        """
        return _StepData.StepData_Described_As(self, *args)

    def CField(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        StepData_Field

        Description
        -----------
        Returns a field from its name; read or write.

        """
        return _StepData.StepData_Described_CField(self, *args)

    def Check(self, *args):
        r"""

        Parameters
        ----------
        ach: Interface_Check

        Return
        -------
        None

        Description
        -----------
        Fills a check by using its description.

        """
        return _StepData.StepData_Described_Check(self, *args)

    def Description(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_EDescr>

        Description
        -----------
        Returns the description used to define this entity.

        """
        return _StepData.StepData_Described_Description(self, *args)

    def Field(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        StepData_Field

        Description
        -----------
        Returns a field from its name; read-only.

        """
        return _StepData.StepData_Described_Field(self, *args)

    def HasField(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        bool

        Description
        -----------
        Tells if a field brings a given name.

        """
        return _StepData.StepData_Described_HasField(self, *args)

    def IsComplex(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if a described entity is complex.

        """
        return _StepData.StepData_Described_IsComplex(self, *args)

    def Matches(self, *args):
        r"""

        Parameters
        ----------
        steptype: str

        Return
        -------
        bool

        Description
        -----------
        Tells if a step type is matched by <self> for a simple entity: own type or super type for a complex entity: one of the members.

        """
        return _StepData.StepData_Described_Matches(self, *args)

    def Shared(self, *args):
        r"""

        Parameters
        ----------
        list: Interface_EntityIterator

        Return
        -------
        None

        Description
        -----------
        Fills an entityiterator with entities shared by <self>.

        """
        return _StepData.StepData_Described_Shared(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_Described

# Register StepData_Described in _StepData:
_StepData.StepData_Described_swigregister(StepData_Described)
class StepData_EDescr(OCC.Core.Standard.Standard_Transient):
    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")
    __repr__ = _swig_repr

    def IsComplex(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if a edescr is complex (ecdescr) or simple (esdescr).

        """
        return _StepData.StepData_EDescr_IsComplex(self, *args)

    def Matches(self, *args):
        r"""

        Parameters
        ----------
        steptype: str

        Return
        -------
        bool

        Description
        -----------
        Tells if a esdescr matches a step type: exact or super type.

        """
        return _StepData.StepData_EDescr_Matches(self, *args)

    def NewEntity(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_Described>

        Description
        -----------
        Creates a described entity (i.e. a simple one).

        """
        return _StepData.StepData_EDescr_NewEntity(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_EDescr

# Register StepData_EDescr in _StepData:
_StepData.StepData_EDescr_swigregister(StepData_EDescr)
class StepData_EnumTool(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"""

        Parameters
        ----------
        e0: str (optional, default to )
        e1: str (optional, default to )
        e2: str (optional, default to )
        e3: str (optional, default to )
        e4: str (optional, default to )
        e5: str (optional, default to )
        e6: str (optional, default to )
        e7: str (optional, default to )
        e8: str (optional, default to )
        e9: str (optional, default to )
        e10: str (optional, default to )
        e11: str (optional, default to )
        e12: str (optional, default to )
        e13: str (optional, default to )
        e14: str (optional, default to )
        e15: str (optional, default to )
        e16: str (optional, default to )
        e17: str (optional, default to )
        e18: str (optional, default to )
        e19: str (optional, default to )
        e20: str (optional, default to )
        e21: str (optional, default to )
        e22: str (optional, default to )
        e23: str (optional, default to )
        e24: str (optional, default to )
        e25: str (optional, default to )
        e26: str (optional, default to )
        e27: str (optional, default to )
        e28: str (optional, default to )
        e29: str (optional, default to )
        e30: str (optional, default to )
        e31: str (optional, default to )
        e32: str (optional, default to )
        e33: str (optional, default to )
        e34: str (optional, default to )
        e35: str (optional, default to )
        e36: str (optional, default to )
        e37: str (optional, default to )
        e38: str (optional, default to )
        e39: str (optional, default to )

        Return
        -------
        None

        Description
        -----------
        Creates an enumtool with definitions given by e0 .. e<max> each definition string can bring one term, or several separated by blanks. each term corresponds to one value of the enumeration, if dots are not presents they are added //! such a static constructor allows to build a static description as: static stepdata_enumtool myenumtool('e0','e1'...); then use it without having to initialise it //! a null definition can be input by given '$' :the corresponding position is attached to 'null/undefined' value (as one particular item of the enumeration list).

        """
        _StepData.StepData_EnumTool_swiginit(self, _StepData.new_StepData_EnumTool(*args))

    def AddDefinition(self, *args):
        r"""

        Parameters
        ----------
        term: str

        Return
        -------
        None

        Description
        -----------
        Processes a definition, splits it according blanks if any empty definitions are ignored a null definition can be input by given '$' :the corresponding position is attached to 'null/undefined' value (as one particular item of the enumeration list) see also isset.

        """
        return _StepData.StepData_EnumTool_AddDefinition(self, *args)

    def IsSet(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if at least one definition has been entered after creation time (i.e. by adddefinition only) //! this allows to build a static description by a first pass: static stepdata_enumtool myenumtool('e0' ...); ... if (!myenumtool.isset()) { for further inits myenumtool.adddefinition('e21'); ... }.

        """
        return _StepData.StepData_EnumTool_IsSet(self, *args)

    def MaxValue(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the maximum integer for a suitable value remark: while values begin at zero, maxvalue is the count of recorded values minus one.

        """
        return _StepData.StepData_EnumTool_MaxValue(self, *args)

    def NullValue(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the value attached to 'null/undefined value' if none is specified or if optional has been set to false, returns -1 null value has been specified by definition '$'.

        """
        return _StepData.StepData_EnumTool_NullValue(self, *args)

    def Optional(self, *args):
        r"""

        Parameters
        ----------
        mode: bool

        Return
        -------
        None

        Description
        -----------
        Sets or unsets the enumtool to accept undefined value (for optional field). ignored if no null value is defined (by '$') can be changed during execution (to read each field), default is true (if a null value is defined).

        """
        return _StepData.StepData_EnumTool_Optional(self, *args)

    def Text(self, *args):
        r"""

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

        Return
        -------
        TCollection_AsciiString

        Description
        -----------
        Returns the text which corresponds to a given numeric value it is limited by dots if num is out of range, returns an empty string.

        """
        return _StepData.StepData_EnumTool_Text(self, *args)

    def Value(self, *args):
        r"""

        Parameters
        ----------
        txt: str

        Return
        -------
        int

        Description
        -----------
        Returns the numeric value found for a text the text must be in capitals and limited by dots a non-suitable text gives a negative value to be returned.

        Parameters
        ----------
        txt: str

        Return
        -------
        int

        Description
        -----------
        Same as above but works on an asciistring.

        """
        return _StepData.StepData_EnumTool_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_EnumTool

# Register StepData_EnumTool in _StepData:
_StepData.StepData_EnumTool_swigregister(StepData_EnumTool)
class StepData_Field(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"""
        Return
        -------
        None

        Description
        -----------
        Creates a field, empty ('no value defined').

        Parameters
        ----------
        other: StepData_Field
        copy: bool (optional, default to Standard_False)

        Return
        -------
        None

        Description
        -----------
        Creates a field from another one. if <copy> is true, handled data (select,string,list, not entities) are copied.

        """
        _StepData.StepData_Field_swiginit(self, _StepData.new_StepData_Field(*args))

    def Arity(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Arity(self, *args)

    def Boolean(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Boolean(self, *args)

    def Clear(self, *args):
        r"""

        Parameters
        ----------
        kind: int (optional, default to 0)

        Return
        -------
        None

        Description
        -----------
        Clears the field, to set it as 'no value defined' just before setlist, predeclares it as 'any' a kind can be directly set here to declare a type.

        """
        return _StepData.StepData_Field_Clear(self, *args)

    def ClearItem(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Declares an item of the list as undefined (ignored if list not defined as string,entity or any).

        """
        return _StepData.StepData_Field_ClearItem(self, *args)

    def CopyFrom(self, *args):
        r"""

        Parameters
        ----------
        other: StepData_Field

        Return
        -------
        None

        Description
        -----------
        Gets the copy of the values of another field.

        """
        return _StepData.StepData_Field_CopyFrom(self, *args)

    def Entity(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        opencascade::handle<Standard_Transient>

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Entity(self, *args)

    def Enum(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        int

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Enum(self, *args)

    def EnumText(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        str

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_EnumText(self, *args)

    def Int(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Int(self, *args)

    def Integer(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        int

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Integer(self, *args)

    def IsSet(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_IsSet(self, *args)

    def ItemKind(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        int

        Description
        -----------
        Returns the kind of an item in a list or double list it is the kind of the list, except if it is 'any', in such a case the true kind is determined and returned.

        """
        return _StepData.StepData_Field_ItemKind(self, *args)

    def Kind(self, *args):
        r"""

        Parameters
        ----------
        type: bool (optional, default to Standard_True)

        Return
        -------
        int

        Description
        -----------
        Returns the kind of the field <type> true (d): returns only the type itself else, returns the complete kind.

        """
        return _StepData.StepData_Field_Kind(self, *args)

    def Length(self, *args):
        r"""

        Parameters
        ----------
        index: int (optional, default to 1)

        Return
        -------
        int

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Length(self, *args)

    def Logical(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        StepData_Logical

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Logical(self, *args)

    def Lower(self, *args):
        r"""

        Parameters
        ----------
        index: int (optional, default to 1)

        Return
        -------
        int

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Lower(self, *args)

    def Real(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        float

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Real(self, *args)

    def Set(self, *args):
        r"""

        Parameters
        ----------
        val: Standard_Transient

        Return
        -------
        None

        Description
        -----------
        Sets an undetermined value: can be string, selectmember, harray(1-2) ... else, an entity in case of an harray, determines and records its size(s).

        """
        return _StepData.StepData_Field_Set(self, *args)

    def SetBoolean(self, *args):
        r"""

        Parameters
        ----------
        val: bool (optional, default to Standard_False)

        Return
        -------
        None

        Description
        -----------
        Sets a boolean value (or predeclares a list as boolean).

        Parameters
        ----------
        num: int
        val: bool

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_SetBoolean(self, *args)

    def SetDerived(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Codes a field as derived (no proper value).

        """
        return _StepData.StepData_Field_SetDerived(self, *args)

    def SetEntity(self, *args):
        r"""

        Parameters
        ----------
        val: Standard_Transient

        Return
        -------
        None

        Description
        -----------
        Sets an entity value.
        Return
        -------
        None

        Description
        -----------
        Predeclares a list as of entity.

        Parameters
        ----------
        num: int
        val: Standard_Transient

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_SetEntity(self, *args)

    def SetEnum(self, *args):
        r"""

        Parameters
        ----------
        val: int (optional, default to -1)
        text: str (optional, default to )

        Return
        -------
        None

        Description
        -----------
        Sets an enum value (as its integer counterpart) (or predeclares a list as enum) if <text> is given , also sets its textual expression <val> negative means unknown (known values begin at 0).

        Parameters
        ----------
        num: int
        val: int
        text: str (optional, default to )

        Return
        -------
        None

        Description
        -----------
        Sets an enum value (integer counterpart), also its text expression if known (if list has been set as 'any').

        """
        return _StepData.StepData_Field_SetEnum(self, *args)

    def SetInt(self, *args):
        r"""

        Parameters
        ----------
        val: int

        Return
        -------
        None

        Description
        -----------
        Directly sets the integer value, if its kind matches integer, boolean, logical, or enum (does not change kind).

        Parameters
        ----------
        num: int
        val: int
        kind: int

        Return
        -------
        None

        Description
        -----------
        Internal access to an integer value for a list, plus its kind.

        """
        return _StepData.StepData_Field_SetInt(self, *args)

    def SetInteger(self, *args):
        r"""

        Parameters
        ----------
        val: int (optional, default to 0)

        Return
        -------
        None

        Description
        -----------
        Sets an integer value (before setlist* declares it as integer).

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

        Return
        -------
        None

        Description
        -----------
        Sets an integer value for a list (rank num) (recognizes a selectmember).

        """
        return _StepData.StepData_Field_SetInteger(self, *args)

    def SetList(self, *args):
        r"""

        Parameters
        ----------
        size: int
        first: int (optional, default to 1)

        Return
        -------
        None

        Description
        -----------
        Declares a field as a list, with an initial size initial lower is defaulted as 1, can be defined the list starts empty, typed by the last set* if no set* before, sets it as 'any' (transient/select).

        """
        return _StepData.StepData_Field_SetList(self, *args)

    def SetList2(self, *args):
        r"""

        Parameters
        ----------
        siz1: int
        siz2: int
        f1: int (optional, default to 1)
        f2: int (optional, default to 1)

        Return
        -------
        None

        Description
        -----------
        Declares a field as an homogeneous square list, with initial sizes, and initial lowers.

        """
        return _StepData.StepData_Field_SetList2(self, *args)

    def SetLogical(self, *args):
        r"""

        Parameters
        ----------
        val: StepData_Logical (optional, default to StepData_LFalse)

        Return
        -------
        None

        Description
        -----------
        Sets a logical value (or predeclares a list as logical).

        Parameters
        ----------
        num: int
        val: StepData_Logical

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_SetLogical(self, *args)

    def SetReal(self, *args):
        r"""

        Parameters
        ----------
        val: float (optional, default to 0.0)

        Return
        -------
        None

        Description
        -----------
        Sets a real value (or predeclares a list as real);.

        Parameters
        ----------
        num: int
        val: float

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_SetReal(self, *args)

    def SetSelectMember(self, *args):
        r"""

        Parameters
        ----------
        val: StepData_SelectMember

        Return
        -------
        None

        Description
        -----------
        Sets a selectmember (for integer,boolean,enum,real,logical) hence, the value of the field is accessed through this member.

        """
        return _StepData.StepData_Field_SetSelectMember(self, *args)

    def SetString(self, *args):
        r"""

        Parameters
        ----------
        val: str (optional, default to )

        Return
        -------
        None

        Description
        -----------
        Sets a string value (or predeclares a list as string) does not redefine the kind if it is already string or enum.

        Parameters
        ----------
        num: int
        val: str

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_SetString(self, *args)

    def String(self, *args):
        r"""

        Parameters
        ----------
        n1: int (optional, default to 1)
        n2: int (optional, default to 1)

        Return
        -------
        str

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_String(self, *args)

    def Transient(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Standard_Transient>

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_Field_Transient(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_Field

# Register StepData_Field in _StepData:
_StepData.StepData_Field_swigregister(StepData_Field)
class StepData_FieldList(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"""
        Return
        -------
        None

        Description
        -----------
        Creates a fieldlist of 0 field.

        """
        _StepData.StepData_FieldList_swiginit(self, _StepData.new_StepData_FieldList(*args))

    def CField(self, *args):
        r"""

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

        Return
        -------
        StepData_Field

        Description
        -----------
        Returns the field n0 <num> between 1 and nbfields, in order to modify its content.

        """
        return _StepData.StepData_FieldList_CField(self, *args)

    def Field(self, *args):
        r"""

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

        Return
        -------
        StepData_Field

        Description
        -----------
        Returns the field n0 <num> between 1 and nbfields (read only).

        """
        return _StepData.StepData_FieldList_Field(self, *args)

    def FillShared(self, *args):
        r"""

        Parameters
        ----------
        iter: Interface_EntityIterator

        Return
        -------
        None

        Description
        -----------
        Fills an iterator with the entities shared by <self>.

        """
        return _StepData.StepData_FieldList_FillShared(self, *args)

    def NbFields(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the count of fields. here, returns 0.

        """
        return _StepData.StepData_FieldList_NbFields(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_FieldList

# Register StepData_FieldList in _StepData:
_StepData.StepData_FieldList_swigregister(StepData_FieldList)
class StepData_FileRecognizer(OCC.Core.Standard.Standard_Transient):
    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")
    __repr__ = _swig_repr

    def Add(self, *args):
        r"""

        Parameters
        ----------
        reco: StepData_FileRecognizer

        Return
        -------
        None

        Description
        -----------
        Adds a new recognizer to the compound, at the end several calls to add work by adding in the order of calls: hence, when eval has failed to recognize, evaluate will call evaluate from the first added recognizer if there is one, and to the second if there is still no result, and so on.

        """
        return _StepData.StepData_FileRecognizer_Add(self, *args)

    def Evaluate(self, *args):
        r"""

        Parameters
        ----------
        akey: str
        res: Standard_Transient

        Return
        -------
        bool

        Description
        -----------
        Evaluates if recognition has a result, returns it if yes in case of success, returns true and puts result in 'res' in case of failure, simply returns false works by calling deferred method eval, and in case of failure, looks for added recognizers to work.

        """
        return _StepData.StepData_FileRecognizer_Evaluate(self, *args)

    def Result(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Standard_Transient>

        Description
        -----------
        Returns result of last recognition (call of evaluate).

        """
        return _StepData.StepData_FileRecognizer_Result(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_FileRecognizer

# Register StepData_FileRecognizer in _StepData:
_StepData.StepData_FileRecognizer_swigregister(StepData_FileRecognizer)
class StepData_GeneralModule(OCC.Core.Interface.Interface_GeneralModule):
    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")
    __repr__ = _swig_repr


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_GeneralModule

# Register StepData_GeneralModule in _StepData:
_StepData.StepData_GeneralModule_swigregister(StepData_GeneralModule)
class StepData_GlobalFactors(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")
    __repr__ = _swig_repr

    def CascadeUnit(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns length unit for current transfer process (mm by default).

        """
        return _StepData.StepData_GlobalFactors_CascadeUnit(self, *args)

    def FactorDegreeRadian(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns transient factor degree radian for conversion of angles at one stage of transfer process.

        """
        return _StepData.StepData_GlobalFactors_FactorDegreeRadian(self, *args)

    def FactorRadianDegree(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns transient factor radian degree for conversion of angles at one stage of transfer process.

        """
        return _StepData.StepData_GlobalFactors_FactorRadianDegree(self, *args)

    def InitializeFactors(self, *args):
        r"""

        Parameters
        ----------
        theLengthFactor: float
        thePlaneAngleFactor: float
        theSolidAngleFactor: float

        Return
        -------
        None

        Description
        -----------
        Initializes the 3 factors for the conversion of units.

        """
        return _StepData.StepData_GlobalFactors_InitializeFactors(self, *args)

    @staticmethod
    def Intance(*args):
        r"""
        Return
        -------
        StepData_GlobalFactors

        Description
        -----------
        Returns a global static object.

        """
        return _StepData.StepData_GlobalFactors_Intance(*args)

    def LengthFactor(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns transient length factor for scaling of shapes at one stage of transfer process.

        """
        return _StepData.StepData_GlobalFactors_LengthFactor(self, *args)

    def PlaneAngleFactor(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns transient plane angle factor for conversion of angles at one stage of transfer process.

        """
        return _StepData.StepData_GlobalFactors_PlaneAngleFactor(self, *args)

    def SetCascadeUnit(self, *args):
        r"""

        Parameters
        ----------
        theUnit: float

        Return
        -------
        None

        Description
        -----------
        Sets length unit for current transfer process.

        """
        return _StepData.StepData_GlobalFactors_SetCascadeUnit(self, *args)

    def SolidAngleFactor(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns transient solid angle factor for conversion of angles at one stage of transfer process.

        """
        return _StepData.StepData_GlobalFactors_SolidAngleFactor(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_GlobalFactors

# Register StepData_GlobalFactors in _StepData:
_StepData.StepData_GlobalFactors_swigregister(StepData_GlobalFactors)
class StepData_GlobalNodeOfWriterLib(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"""
        Return
        -------
        None

        Description
        -----------
        Creates an empty globalnode, with no next.

        """
        _StepData.StepData_GlobalNodeOfWriterLib_swiginit(self, _StepData.new_StepData_GlobalNodeOfWriterLib(*args))

    def Add(self, *args):
        r"""

        Parameters
        ----------
        amodule: StepData_ReadWriteModule
        aprotocol: StepData_Protocol

        Return
        -------
        None

        Description
        -----------
        Adds a module bound with a protocol to the list: does nothing if already in the list, that is, same type (exact match) and same state (that is, isequal is not required) once added, stores its attached protocol in correspondence.

        """
        return _StepData.StepData_GlobalNodeOfWriterLib_Add(self, *args)

    def Module(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_ReadWriteModule>

        Description
        -----------
        Returns the module stored in a given globalnode.

        """
        return _StepData.StepData_GlobalNodeOfWriterLib_Module(self, *args)

    def Next(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_GlobalNodeOfWriterLib>

        Description
        -----------
        Returns the next globalnode. if none is defined, returned value is a null handle.

        """
        return _StepData.StepData_GlobalNodeOfWriterLib_Next(self, *args)

    def Protocol(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_Protocol>

        Description
        -----------
        Returns the attached protocol stored in a given globalnode.

        """
        return _StepData.StepData_GlobalNodeOfWriterLib_Protocol(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_GlobalNodeOfWriterLib

# Register StepData_GlobalNodeOfWriterLib in _StepData:
_StepData.StepData_GlobalNodeOfWriterLib_swigregister(StepData_GlobalNodeOfWriterLib)
class StepData_NodeOfWriterLib(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"""
        Return
        -------
        None

        Description
        -----------
        Creates an empty node, with no next.

        """
        _StepData.StepData_NodeOfWriterLib_swiginit(self, _StepData.new_StepData_NodeOfWriterLib(*args))

    def AddNode(self, *args):
        r"""

        Parameters
        ----------
        anode: StepData_GlobalNodeOfWriterLib

        Return
        -------
        None

        Description
        -----------
        Adds a couple (module,protocol), that is, stores it into itself if not yet done, else creates a next node to do it.

        """
        return _StepData.StepData_NodeOfWriterLib_AddNode(self, *args)

    def Module(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_ReadWriteModule>

        Description
        -----------
        Returns the module designated by a precise node.

        """
        return _StepData.StepData_NodeOfWriterLib_Module(self, *args)

    def Next(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_NodeOfWriterLib>

        Description
        -----------
        Returns the next node. if none was defined, returned value is a null handle.

        """
        return _StepData.StepData_NodeOfWriterLib_Next(self, *args)

    def Protocol(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_Protocol>

        Description
        -----------
        Returns the protocol designated by a precise node.

        """
        return _StepData.StepData_NodeOfWriterLib_Protocol(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_NodeOfWriterLib

# Register StepData_NodeOfWriterLib in _StepData:
_StepData.StepData_NodeOfWriterLib_swigregister(StepData_NodeOfWriterLib)
class StepData_PDescr(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"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _StepData.StepData_PDescr_swiginit(self, _StepData.new_StepData_PDescr(*args))

    def AddArity(self, *args):
        r"""

        Parameters
        ----------
        arity: int (optional, default to 1)

        Return
        -------
        None

        Description
        -----------
        Adds an arity count to <self>, by default 1 1: a simple field passes to a list/array etc or a list to a list of list 2: a simple field passes to a list of list.

        """
        return _StepData.StepData_PDescr_AddArity(self, *args)

    def AddEnumDef(self, *args):
        r"""

        Parameters
        ----------
        enumdef: str

        Return
        -------
        None

        Description
        -----------
        Adds an enum value as a string.

        """
        return _StepData.StepData_PDescr_AddEnumDef(self, *args)

    def AddMember(self, *args):
        r"""

        Parameters
        ----------
        member: StepData_PDescr

        Return
        -------
        None

        Description
        -----------
        Adds a member to a select description.

        """
        return _StepData.StepData_PDescr_AddMember(self, *args)

    def Arity(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the arity of <self>.

        """
        return _StepData.StepData_PDescr_Arity(self, *args)

    def Check(self, *args):
        r"""

        Parameters
        ----------
        afild: StepData_Field
        ach: Interface_Check

        Return
        -------
        None

        Description
        -----------
        Semantic check of a field: does it complies with the given description ?.

        """
        return _StepData.StepData_PDescr_Check(self, *args)

    def DescrName(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        Returns the description (type name) to match, for a described (else, empty string).

        """
        return _StepData.StepData_PDescr_DescrName(self, *args)

    def EnumMax(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the maximum integer for a suitable value (count - 1).

        """
        return _StepData.StepData_PDescr_EnumMax(self, *args)

    def EnumText(self, *args):
        r"""

        Parameters
        ----------
        val: int

        Return
        -------
        str

        Description
        -----------
        Returns the text which corresponds to a numeric value, between 0 and enummax. it is limited by dots.

        """
        return _StepData.StepData_PDescr_EnumText(self, *args)

    def EnumValue(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        int

        Description
        -----------
        Returns the numeric value found for an enum text the text must be in capitals and limited by dots a non-suitable text gives a negative value to be returned.

        """
        return _StepData.StepData_PDescr_EnumValue(self, *args)

    def FieldName(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_PDescr_FieldName(self, *args)

    def FieldRank(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_PDescr_FieldRank(self, *args)

    def IsBoolean(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for a boolean value (false,true).

        """
        return _StepData.StepData_PDescr_IsBoolean(self, *args)

    def IsDerived(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is derived.

        """
        return _StepData.StepData_PDescr_IsDerived(self, *args)

    def IsDescr(self, *args):
        r"""

        Parameters
        ----------
        descr: StepData_EDescr

        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for a described entity of a given edescr (does this edescr match description name ?). for late-bnd (works for <self> + nexts if <self> is a select).

        """
        return _StepData.StepData_PDescr_IsDescr(self, *args)

    def IsEntity(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for an entity, either described or cdl type.

        """
        return _StepData.StepData_PDescr_IsEntity(self, *args)

    def IsEnum(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for an enum value then, call addenumdef ordered from the first one (value 0) managed by an enumtool.

        """
        return _StepData.StepData_PDescr_IsEnum(self, *args)

    def IsField(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is a field. else it is a type.

        """
        return _StepData.StepData_PDescr_IsField(self, *args)

    def IsInteger(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for an integer.

        """
        return _StepData.StepData_PDescr_IsInteger(self, *args)

    def IsLogical(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for a logical value (false,true,unknown).

        """
        return _StepData.StepData_PDescr_IsLogical(self, *args)

    def IsOptional(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is optional.

        """
        return _StepData.StepData_PDescr_IsOptional(self, *args)

    def IsReal(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for a real value.

        """
        return _StepData.StepData_PDescr_IsReal(self, *args)

    def IsSelect(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for a select.

        """
        return _StepData.StepData_PDescr_IsSelect(self, *args)

    def IsString(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for a string value.

        """
        return _StepData.StepData_PDescr_IsString(self, *args)

    def IsType(self, *args):
        r"""

        Parameters
        ----------
        atype: Standard_Type

        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is for an entity of a given cdl type (early-bnd) (works for <self> + nexts if <self> is a select).

        """
        return _StepData.StepData_PDescr_IsType(self, *args)

    def Member(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        opencascade::handle<StepData_PDescr>

        Description
        -----------
        For a select, returns the member whose name matches <name> to this member, the following question can then be asked null handle if <name> not matched or <self> not a select //! remark: not to be asked for an entity type hence, following isinteger .. enum* only apply on <self> and require member while istype applies on <self> and all select members.

        """
        return _StepData.StepData_PDescr_Member(self, *args)

    def Name(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_PDescr_Name(self, *args)

    def SetArity(self, *args):
        r"""

        Parameters
        ----------
        arity: int (optional, default to 1)

        Return
        -------
        None

        Description
        -----------
        Directly sets the arity count 0: simple field 1: list or array etc 2: list of list.

        """
        return _StepData.StepData_PDescr_SetArity(self, *args)

    def SetBoolean(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets <self> for a boolean value (false,true).

        """
        return _StepData.StepData_PDescr_SetBoolean(self, *args)

    def SetDerived(self, *args):
        r"""

        Parameters
        ----------
        der: bool (optional, default to Standard_True)

        Return
        -------
        None

        Description
        -----------
        Sets/unsets <self> to be for a derived field.

        """
        return _StepData.StepData_PDescr_SetDerived(self, *args)

    def SetDescr(self, *args):
        r"""

        Parameters
        ----------
        dscnam: str

        Return
        -------
        None

        Description
        -----------
        Sets <self> for a described entity, whose description must match the type name <dscnam>.

        """
        return _StepData.StepData_PDescr_SetDescr(self, *args)

    def SetEnum(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets <self> for an enum value then, call addenumdef ordered from the first one (value 0).

        """
        return _StepData.StepData_PDescr_SetEnum(self, *args)

    def SetField(self, *args):
        r"""

        Parameters
        ----------
        name: str
        rank: int

        Return
        -------
        None

        Description
        -----------
        Sets <self> to describe a field of an entity with a name and a rank.

        """
        return _StepData.StepData_PDescr_SetField(self, *args)

    def SetFrom(self, *args):
        r"""

        Parameters
        ----------
        other: StepData_PDescr

        Return
        -------
        None

        Description
        -----------
        Sets <self> as <other> but duplicated hence, some definition may be changed.

        """
        return _StepData.StepData_PDescr_SetFrom(self, *args)

    def SetInteger(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets <self> for an integer value.

        """
        return _StepData.StepData_PDescr_SetInteger(self, *args)

    def SetLogical(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets <self> for a logical value (false,true,unknown).

        """
        return _StepData.StepData_PDescr_SetLogical(self, *args)

    def SetMemberName(self, *args):
        r"""

        Parameters
        ----------
        memname: str

        Return
        -------
        None

        Description
        -----------
        Sets a name for select member. to be used if a member is for an immediate type.

        """
        return _StepData.StepData_PDescr_SetMemberName(self, *args)

    def SetName(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_PDescr_SetName(self, *args)

    def SetOptional(self, *args):
        r"""

        Parameters
        ----------
        opt: bool (optional, default to Standard_True)

        Return
        -------
        None

        Description
        -----------
        Sets/unsets <self> to accept undefined values.

        """
        return _StepData.StepData_PDescr_SetOptional(self, *args)

    def SetReal(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets <self> for a real value.

        """
        return _StepData.StepData_PDescr_SetReal(self, *args)

    def SetSelect(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Declares this pdescr to be a select, hence to have members <self> itself can be the first member.

        """
        return _StepData.StepData_PDescr_SetSelect(self, *args)

    def SetString(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets <self> for a string value.

        """
        return _StepData.StepData_PDescr_SetString(self, *args)

    def SetType(self, *args):
        r"""

        Parameters
        ----------
        atype: Standard_Type

        Return
        -------
        None

        Description
        -----------
        Sets <self> for an entity which must match a type (early-bound).

        """
        return _StepData.StepData_PDescr_SetType(self, *args)

    def Simple(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_PDescr>

        Description
        -----------
        For a list or list of list, returns the pdescr for the simpler pdescr. else, returns <self> this allows to have different attributes for optional for instance, on a field, and on the parameter of a list: [optional] list of [optional] ...

        """
        return _StepData.StepData_PDescr_Simple(self, *args)

    def Type(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Standard_Type>

        Description
        -----------
        Returns the type to match (iskind), for a cdl entity (else, null handle).

        """
        return _StepData.StepData_PDescr_Type(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_PDescr

# Register StepData_PDescr in _StepData:
_StepData.StepData_PDescr_swigregister(StepData_PDescr)
class StepData_Protocol(OCC.Core.Interface.Interface_Protocol):
    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"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _StepData.StepData_Protocol_swiginit(self, _StepData.new_StepData_Protocol(*args))

    def AddBasicDescr(self, *args):
        r"""

        Parameters
        ----------
        esdescr: StepData_ESDescr

        Return
        -------
        None

        Description
        -----------
        Records an esdescr, intended to build complex descriptions.

        """
        return _StepData.StepData_Protocol_AddBasicDescr(self, *args)

    def AddDescr(self, *args):
        r"""

        Parameters
        ----------
        adescr: StepData_EDescr
        CN: int

        Return
        -------
        None

        Description
        -----------
        Records an edescr with its case number also records its name for an esdescr (simple type): an esdescr is then used, for case number, or for type name.

        """
        return _StepData.StepData_Protocol_AddDescr(self, *args)

    def AddPDescr(self, *args):
        r"""

        Parameters
        ----------
        pdescr: StepData_PDescr

        Return
        -------
        None

        Description
        -----------
        Records an pdescr.

        """
        return _StepData.StepData_Protocol_AddPDescr(self, *args)

    def BasicDescr(self, *args):
        r"""

        Parameters
        ----------
        name: str
        anylevel: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<StepData_EDescr>

        Description
        -----------
        Returns a basic description according to its name <anylevel> true (d): for <self> and its resources <anylevel> false: for <self> only.

        """
        return _StepData.StepData_Protocol_BasicDescr(self, *args)

    def Descr(self, *args):
        r"""

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

        Return
        -------
        opencascade::handle<StepData_EDescr>

        Description
        -----------
        Returns the description attached to a case number, or null.

        Parameters
        ----------
        name: str
        anylevel: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<StepData_EDescr>

        Description
        -----------
        Returns a description according to its name <anylevel> true (d): for <self> and its resources <anylevel> false: for <self> only.

        """
        return _StepData.StepData_Protocol_Descr(self, *args)

    def DescrNumber(self, *args):
        r"""

        Parameters
        ----------
        adescr: StepData_EDescr

        Return
        -------
        int

        Description
        -----------
        Returns a unique positive casenumber for types described by an edescr (late binding) warning: typenumber and descrnumber must give together a unique positive case number for each distinct case, type or descr.

        """
        return _StepData.StepData_Protocol_DescrNumber(self, *args)

    def ECDescr(self, *args):
        r"""

        Parameters
        ----------
        names: TColStd_SequenceOfAsciiString
        anylevel: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<StepData_ECDescr>

        Description
        -----------
        Returns a complex description according to list of names <anylevel> true (d): for <self> and its resources <anylevel> false: for <self> only.

        """
        return _StepData.StepData_Protocol_ECDescr(self, *args)

    def ESDescr(self, *args):
        r"""

        Parameters
        ----------
        name: str
        anylevel: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<StepData_ESDescr>

        Description
        -----------
        Idem as descr but cast to simple description.

        """
        return _StepData.StepData_Protocol_ESDescr(self, *args)

    def HasDescr(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if a protocol brings at least one esdescr, i.e. if it defines at least one entity description by esdescr mechanism.

        """
        return _StepData.StepData_Protocol_HasDescr(self, *args)

    def PDescr(self, *args):
        r"""

        Parameters
        ----------
        name: str
        anylevel: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<StepData_PDescr>

        Description
        -----------
        Returns a parameter description according to its name <anylevel> true (d): for <self> and its resources <anylevel> false: for <self> only.

        """
        return _StepData.StepData_Protocol_PDescr(self, *args)

    def SchemaName(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        Returns the schema name attached to each class of protocol to be redefined by each sub-class here, schemaname returns '(default)' was c++: return const.

        """
        return _StepData.StepData_Protocol_SchemaName(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_Protocol

# Register StepData_Protocol in _StepData:
_StepData.StepData_Protocol_swigregister(StepData_Protocol)
class StepData_ReadWriteModule(OCC.Core.Interface.Interface_ReaderModule):
    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")
    __repr__ = _swig_repr

    def CaseStep(self, *args):
        r"""

        Parameters
        ----------
        atype: str

        Return
        -------
        int

        Description
        -----------
        Defines case numbers corresponding to the recognized types called by casenum (data,num) above for a simple type entity warning: casestep must give the same value as protocol does for the entity type which corresponds to this type given as a string.

        Parameters
        ----------
        types: TColStd_SequenceOfAsciiString

        Return
        -------
        int

        Description
        -----------
        Same a above but for a complex type entity ('plex') the provided default recognizes nothing.

        """
        return _StepData.StepData_ReadWriteModule_CaseStep(self, *args)

    def ComplexType(self, *args):
        r"""

        Parameters
        ----------
        CN: int
        types: TColStd_SequenceOfAsciiString

        Return
        -------
        bool

        Description
        -----------
        Function specific to step, which delivers the list of types which corresponds to a complex type. if <cn> is not for a complex type, this method returns false. else it returns true and fills the list in alphabetic order. the default returns false. to be redefined as required.

        """
        return _StepData.StepData_ReadWriteModule_ComplexType(self, *args)

    def IsComplex(self, *args):
        r"""

        Parameters
        ----------
        CN: int

        Return
        -------
        bool

        Description
        -----------
        Returns true if the case number corresponds to a complex type ('plex'). remember that all possible combinations must be aknowledged to be processed default is false for all cases. for a protocol which defines possible plexes, this method must be redefined.

        """
        return _StepData.StepData_ReadWriteModule_IsComplex(self, *args)

    def ReadStep(self, *args):
        r"""

        Parameters
        ----------
        CN: int
        data: StepData_StepReaderData
        num: int
        ach: Interface_Check
        ent: Standard_Transient

        Return
        -------
        None

        Description
        -----------
        Specific read function. works with stepreaderdata.

        """
        return _StepData.StepData_ReadWriteModule_ReadStep(self, *args)

    def ShortType(self, *args):
        r"""

        Parameters
        ----------
        CN: int

        Return
        -------
        TCollection_AsciiString

        Description
        -----------
        Function specific to step. some step types have a short form this method can be redefined to fill it by default, returns an empty string, which is then interpreted to take normal form from steptype.

        """
        return _StepData.StepData_ReadWriteModule_ShortType(self, *args)

    def StepType(self, *args):
        r"""

        Parameters
        ----------
        CN: int

        Return
        -------
        TCollection_AsciiString

        Description
        -----------
        Function specific to step, which delivers the steptype as it is recorded in and read from a file compliant with step. this method is symmetric to the method casestep. steptype can be different from dynamic type's name, but belongs to the same class of object. returns an empty string if <cn> is zero. warning: for a complex type entity, returns an empty string (complex type must be managed by users).

        """
        return _StepData.StepData_ReadWriteModule_StepType(self, *args)

    def WriteStep(self, *args):
        r"""

        Parameters
        ----------
        CN: int
        SW: StepData_StepWriter
        ent: Standard_Transient

        Return
        -------
        None

        Description
        -----------
        Write function, switched by casenum.

        """
        return _StepData.StepData_ReadWriteModule_WriteStep(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_ReadWriteModule

# Register StepData_ReadWriteModule in _StepData:
_StepData.StepData_ReadWriteModule_swigregister(StepData_ReadWriteModule)
class StepData_SelectMember(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"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _StepData.StepData_SelectMember_swiginit(self, _StepData.new_StepData_SelectMember(*args))

    def Boolean(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_Boolean(self, *args)

    def Enum(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_Enum(self, *args)

    def EnumText(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_EnumText(self, *args)

    def HasName(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Tells if a selectmember has a name. default is false.

        """
        return _StepData.StepData_SelectMember_HasName(self, *args)

    def Int(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        This internal method gives access to a value implemented by an integer (to read it).

        """
        return _StepData.StepData_SelectMember_Int(self, *args)

    def Integer(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Gets the value as an integer.

        """
        return _StepData.StepData_SelectMember_Integer(self, *args)

    def Kind(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_Kind(self, *args)

    def Logical(self, *args):
        r"""
        Return
        -------
        StepData_Logical

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_Logical(self, *args)

    def Matches(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        bool

        Description
        -----------
        Tells if the name of a selectmember matches a given one by default, compares the strings, can be redefined (optimised).

        """
        return _StepData.StepData_SelectMember_Matches(self, *args)

    def Name(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        Returns the name of a selectmember. default is empty.

        """
        return _StepData.StepData_SelectMember_Name(self, *args)

    def ParamType(self, *args):
        r"""
        Return
        -------
        Interface_ParamType

        Description
        -----------
        Returns the kind of the selectmember, under the form of an enum paramtype.

        """
        return _StepData.StepData_SelectMember_ParamType(self, *args)

    def Real(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_Real(self, *args)

    def SetBoolean(self, *args):
        r"""

        Parameters
        ----------
        val: bool

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_SetBoolean(self, *args)

    def SetEnum(self, *args):
        r"""

        Parameters
        ----------
        val: int
        text: str (optional, default to )

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_SetEnum(self, *args)

    def SetEnumText(self, *args):
        r"""

        Parameters
        ----------
        val: int
        text: str

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_SetEnumText(self, *args)

    def SetInt(self, *args):
        r"""

        Parameters
        ----------
        val: int

        Return
        -------
        None

        Description
        -----------
        This internal method gives access to a value implemented by an integer (to set it).

        """
        return _StepData.StepData_SelectMember_SetInt(self, *args)

    def SetInteger(self, *args):
        r"""

        Parameters
        ----------
        val: int

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_SetInteger(self, *args)

    def SetKind(self, *args):
        r"""

        Parameters
        ----------
        kind: int

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_SetKind(self, *args)

    def SetLogical(self, *args):
        r"""

        Parameters
        ----------
        val: StepData_Logical

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_SetLogical(self, *args)

    def SetName(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        bool

        Description
        -----------
        Sets the name of a selectmember, returns true if done, false if no name is allowed default does nothing and returns false.

        """
        return _StepData.StepData_SelectMember_SetName(self, *args)

    def SetReal(self, *args):
        r"""

        Parameters
        ----------
        val: float

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_SetReal(self, *args)

    def SetString(self, *args):
        r"""

        Parameters
        ----------
        val: str

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_SetString(self, *args)

    def String(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectMember_String(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_SelectMember

# Register StepData_SelectMember in _StepData:
_StepData.StepData_SelectMember_swigregister(StepData_SelectMember)
class StepData_SelectType(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")
    __repr__ = _swig_repr

    def Boolean(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectType_Boolean(self, *args)

    def CaseMem(self, *args):
        r"""

        Parameters
        ----------
        ent: StepData_SelectMember

        Return
        -------
        int

        Description
        -----------
        Recognize a selectmember (kind, name). returns a positive value which identifies the case in the list of immediate cases (distinct from the list of entity types). zero if not recognizes default returns 0, saying that no immediate value is allowed.

        """
        return _StepData.StepData_SelectType_CaseMem(self, *args)

    def CaseMember(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the type of the stored selectmember, or zero if it is null or entity. calls the method casemem on value.

        """
        return _StepData.StepData_SelectType_CaseMember(self, *args)

    def CaseNum(self, *args):
        r"""

        Parameters
        ----------
        ent: Standard_Transient

        Return
        -------
        int

        Description
        -----------
        Recognizes the type of an entity. returns a positive number which identifies the type in the definition list of the selecttype. returns zero if its type in not in this list.

        """
        return _StepData.StepData_SelectType_CaseNum(self, *args)

    def CaseNumber(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Recognizes the type of the stored entity, or zero if it is null or selectmember. calls the first method casenum on value.

        """
        return _StepData.StepData_SelectType_CaseNumber(self, *args)

    def Description(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_PDescr>

        Description
        -----------
        Returns the description which corresponds to <self> null if no specific description to give. this description is used to control reading an check validity. default returns a null handle, i.e. undefined description it can suffice if casenum and casemem give enough control.

        """
        return _StepData.StepData_SelectType_Description(self, *args)

    def Int(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        This internal method gives access to a value implemented by an integer (to read it).

        """
        return _StepData.StepData_SelectType_Int(self, *args)

    def Integer(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Gets the value as an integer.

        """
        return _StepData.StepData_SelectType_Integer(self, *args)

    def IsNull(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if there is no stored entity (i.e. it is null).

        """
        return _StepData.StepData_SelectType_IsNull(self, *args)

    def Logical(self, *args):
        r"""
        Return
        -------
        StepData_Logical

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectType_Logical(self, *args)

    def Matches(self, *args):
        r"""

        Parameters
        ----------
        ent: Standard_Transient

        Return
        -------
        bool

        Description
        -----------
        Returns true if the type of an entity complies with the definition list of the selecttype. also checks for a selectmember default implementation looks for casenum or casemem positive.

        """
        return _StepData.StepData_SelectType_Matches(self, *args)

    def Member(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_SelectMember>

        Description
        -----------
        Returns value as a selectmember. null if not a selectmember.

        """
        return _StepData.StepData_SelectType_Member(self, *args)

    def NewMember(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_SelectMember>

        Description
        -----------
        Returns a preferred selectmember. default returns a null by default, a selectmember can be set according to data type and name: it is a selectnamed if name is defined //! this method allows to define, for a specific selecttype, a specific selectmember than selectnamed. for instance for a real plus a name, a selectreal plus a case number is a good solution, lighter than selectnamed which is very multipurpose.

        """
        return _StepData.StepData_SelectType_NewMember(self, *args)

    def Nullify(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Nullifies the stored entity.

        """
        return _StepData.StepData_SelectType_Nullify(self, *args)

    def Real(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectType_Real(self, *args)

    def SelectName(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        Returns the type name of selectmember. if no selectmember or with no type name, returns an empty string to change it, pass through the selectmember itself.

        """
        return _StepData.StepData_SelectType_SelectName(self, *args)

    def SetBoolean(self, *args):
        r"""

        Parameters
        ----------
        val: bool
        name: str (optional, default to )

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectType_SetBoolean(self, *args)

    def SetInt(self, *args):
        r"""

        Parameters
        ----------
        val: int

        Return
        -------
        None

        Description
        -----------
        This internal method gives access to a value implemented by an integer (to set it): a selectmember must already be there !.

        """
        return _StepData.StepData_SelectType_SetInt(self, *args)

    def SetInteger(self, *args):
        r"""

        Parameters
        ----------
        val: int
        name: str (optional, default to )

        Return
        -------
        None

        Description
        -----------
        Sets a new integer value, with an optional type name warning: if a selectmember is already set, works on it: value and name must then be accepted by this selectmember.

        """
        return _StepData.StepData_SelectType_SetInteger(self, *args)

    def SetLogical(self, *args):
        r"""

        Parameters
        ----------
        val: StepData_Logical
        name: str (optional, default to )

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectType_SetLogical(self, *args)

    def SetReal(self, *args):
        r"""

        Parameters
        ----------
        val: float
        name: str (optional, default to )

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectType_SetReal(self, *args)

    def SetValue(self, *args):
        r"""

        Parameters
        ----------
        ent: Standard_Transient

        Return
        -------
        None

        Description
        -----------
        Stores an entity. this allows to define a specific selecttype class with one read method per member type, which returns the value casted with the good type.

        """
        return _StepData.StepData_SelectType_SetValue(self, *args)

    def Type(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Standard_Type>

        Description
        -----------
        Returns the effective (dynamic) type of the stored entity if it is null, returns type(transient).

        """
        return _StepData.StepData_SelectType_Type(self, *args)

    def Value(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Standard_Transient>

        Description
        -----------
        Returns the stored entity. can be used to define specific read methods (see above).

        """
        return _StepData.StepData_SelectType_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_SelectType

# Register StepData_SelectType in _StepData:
_StepData.StepData_SelectType_swigregister(StepData_SelectType)
class StepData_StepDumper(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"""

        Parameters
        ----------
        amodel: StepData_StepModel
        protocol: StepData_Protocol
        mode: int (optional, default to 0)

        Return
        -------
        None

        Description
        -----------
        Creates a stepdumper, able to work on a given stepmodel (which defines the total scope for dumping entities) and a given protocol from step (which defines the authorized types to be dumped) <mode> commands what is to be displayed (number or label) 0 for number (and corresponding labels are displayed apart) 1 for label (and corresponding numbers are displayed apart) 2 for label without anymore.

        """
        _StepData.StepData_StepDumper_swiginit(self, _StepData.new_StepData_StepDumper(*args))

    def StepWriter(self, *args):
        r"""
        Return
        -------
        StepData_StepWriter

        Description
        -----------
        Gives an access to the tool which is used to work: this allow to acts on some parameters: floating format, scopes ...

        """
        return _StepData.StepData_StepDumper_StepWriter(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_StepDumper

# Register StepData_StepDumper in _StepData:
_StepData.StepData_StepDumper_swigregister(StepData_StepDumper)
class StepData_StepModel(OCC.Core.Interface.Interface_InterfaceModel):
    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"""
        Return
        -------
        None

        Description
        -----------
        Creates an empty step model with an empty header.

        """
        _StepData.StepData_StepModel_swiginit(self, _StepData.new_StepData_StepModel(*args))

    def AddHeaderEntity(self, *args):
        r"""

        Parameters
        ----------
        ent: Standard_Transient

        Return
        -------
        None

        Description
        -----------
        Adds an entity to the header.

        """
        return _StepData.StepData_StepModel_AddHeaderEntity(self, *args)

    def Entity(self, *args):
        r"""

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

        Return
        -------
        opencascade::handle<Standard_Transient>

        Description
        -----------
        Returns entity given its rank. same as interfaceentity, but with a shorter name.

        """
        return _StepData.StepData_StepModel_Entity(self, *args)

    def HasHeaderEntity(self, *args):
        r"""

        Parameters
        ----------
        atype: Standard_Type

        Return
        -------
        bool

        Description
        -----------
        Says if a header entity has a specified type.

        """
        return _StepData.StepData_StepModel_HasHeaderEntity(self, *args)

    def Header(self, *args):
        r"""
        Return
        -------
        Interface_EntityIterator

        Description
        -----------
        Returns header entities under the form of an iterator.

        """
        return _StepData.StepData_StepModel_Header(self, *args)

    def HeaderEntity(self, *args):
        r"""

        Parameters
        ----------
        atype: Standard_Type

        Return
        -------
        opencascade::handle<Standard_Transient>

        Description
        -----------
        Returns header entity with specified type, if there is.

        """
        return _StepData.StepData_StepModel_HeaderEntity(self, *args)

    def IdentLabel(self, *args):
        r"""

        Parameters
        ----------
        ent: Standard_Transient

        Return
        -------
        int

        Description
        -----------
        Returns the label ident attached to an entity, 0 if not in me.

        """
        return _StepData.StepData_StepModel_IdentLabel(self, *args)

    def IsInitializedUnit(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns the unit initialization flag true - the unit was initialized false - the unit value was not initialized, the default value is used.

        """
        return _StepData.StepData_StepModel_IsInitializedUnit(self, *args)

    def LocalLengthUnit(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns local length unit using for transfer process (1 by default).

        """
        return _StepData.StepData_StepModel_LocalLengthUnit(self, *args)

    def SetIdentLabel(self, *args):
        r"""

        Parameters
        ----------
        ent: Standard_Transient
        ident: int

        Return
        -------
        None

        Description
        -----------
        Attaches an ident to an entity to produce a label (does nothing if <ent> is not in <self>).

        """
        return _StepData.StepData_StepModel_SetIdentLabel(self, *args)

    def SetLocalLengthUnit(self, *args):
        r"""

        Parameters
        ----------
        theUnit: float

        Return
        -------
        None

        Description
        -----------
        Sets local length unit using for transfer process.

        """
        return _StepData.StepData_StepModel_SetLocalLengthUnit(self, *args)

    def SetSourceCodePage(self, *args):
        r"""

        Parameters
        ----------
        theCode: Resource_FormatType

        Return
        -------
        None

        Description
        -----------
        Return the encoding of step file for converting names into unicode.

        """
        return _StepData.StepData_StepModel_SetSourceCodePage(self, *args)

    def SetWriteLengthUnit(self, *args):
        r"""

        Parameters
        ----------
        theUnit: float

        Return
        -------
        None

        Description
        -----------
        Sets length unit using for writing process.

        """
        return _StepData.StepData_StepModel_SetWriteLengthUnit(self, *args)

    def SourceCodePage(self, *args):
        r"""
        Return
        -------
        Resource_FormatType

        Description
        -----------
        Return the encoding of step file for converting names into unicode. initialized from 'read.step.codepage' variable by constructor, which is resource_utf8 by default.

        """
        return _StepData.StepData_StepModel_SourceCodePage(self, *args)

    def WriteLengthUnit(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns length unit using for writing process (1 by default).

        """
        return _StepData.StepData_StepModel_WriteLengthUnit(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_StepModel

# Register StepData_StepModel in _StepData:
_StepData.StepData_StepModel_swigregister(StepData_StepModel)
class StepData_StepReaderData(OCC.Core.Interface.Interface_FileReaderData):
    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"""

        Parameters
        ----------
        nbheader: int
        nbtotal: int
        nbpar: int
        theSourceCodePage: Resource_FormatType (optional, default to Resource_FormatType_UTF8)

        Return
        -------
        None

        Description
        -----------
        Creates stepreaderdata correctly dimensionned (necessary at creation time, because it contains arrays) nbheader is nb of records for header, nbtotal for header+data and nbpar gives the total count of parameters.

        """
        _StepData.StepData_StepReaderData_swiginit(self, _StepData.new_StepData_StepReaderData(*args))

    def AddStepParam(self, *args):
        r"""

        Parameters
        ----------
        num: int
        aval: str
        atype: Interface_ParamType
        nument: int (optional, default to 0)

        Return
        -------
        None

        Description
        -----------
        Fills the fields of a parameter of a record. this is a variant of addparam, adapted to step (optimized for specific values).

        """
        return _StepData.StepData_StepReaderData_AddStepParam(self, *args)

    def CType(self, *args):
        r"""

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

        Return
        -------
        str

        Description
        -----------
        Returns record type as a cstring was c++: return const.

        """
        return _StepData.StepData_StepReaderData_CType(self, *args)

    def CheckDerived(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check
        errstat: bool (optional, default to Standard_False)

        Return
        -------
        bool

        Description
        -----------
        Checks if parameter <nump> of record <num> is given as derived if this check is successful (i.e. param = '*'), returns true else, fills <ach> with a message which contains <mess> and returns false. according to <errstat>, this message is warning if errstat is false (default), fail if errstat is true.

        """
        return _StepData.StepData_StepReaderData_CheckDerived(self, *args)

    def CheckNbParams(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nbreq: int
        ach: Interface_Check
        mess: str (optional, default to )

        Return
        -------
        bool

        Description
        -----------
        Checks count of parameters of record <num> to equate <nbreq> if this check is successful, returns true else, fills <ach> with an error message then returns false <mess> is included in the error message if given non empty.

        """
        return _StepData.StepData_StepReaderData_CheckNbParams(self, *args)

    def ComplexType(self, *args):
        r"""

        Parameters
        ----------
        num: int
        types: TColStd_SequenceOfAsciiString

        Return
        -------
        None

        Description
        -----------
        Returns the list of types which correspond to a complex type entity. if not complex, there is just one type in it for a sublist or a scope mark, <types> remains empty.

        """
        return _StepData.StepData_StepReaderData_ComplexType(self, *args)

    def FailEnumValue(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check

        Return
        -------
        None

        Description
        -----------
        Fills a check with a fail message if enumeration value does match parameter definition just a help to centralize message definitions.

        """
        return _StepData.StepData_StepReaderData_FailEnumValue(self, *args)

    def FindNextHeaderRecord(self, *args):
        r"""

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

        Return
        -------
        int

        Description
        -----------
        Determine first suitable record of header works as findnextrecord, but treats only header records.

        """
        return _StepData.StepData_StepReaderData_FindNextHeaderRecord(self, *args)

    def GlobalCheck(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Interface_Check>

        Description
        -----------
        Returns the global check. it can record fail messages about undefined references (detected by setentitynumbers).

        """
        return _StepData.StepData_StepReaderData_GlobalCheck(self, *args)

    def IsComplex(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Returns true if <num> corresponds to a complex type entity (as can be defined by andor express clause).

        """
        return _StepData.StepData_StepReaderData_IsComplex(self, *args)

    def NamedForComplex(self, *args):
        r"""

        Parameters
        ----------
        name: str
        num0: int
        ach: Interface_Check

        Return
        -------
        num: int

        Description
        -----------
        Determines the first component which brings a given name, for a complex type entity <num0> is the very first record of this entity <num> is given the last nextnamedforcomplex, starts at zero it is returned as the newly found number hence, in the normal case, nextnamedforcomplex starts by num0 if <num> is zero, else by nextforcomplex(num) if the alphabetic order is not respected, it restarts from num0 and loops on nextforcomplex until finding <name> in case of 'non-alphabetic order', <ach> is filled with a warning for this name in case of 'not-found at all', <ach> is filled with a fail, and <num> is returned as zero //! returns true if alphabetic order, false else.

        Parameters
        ----------
        theName: str
        theShortName: str
        num0: int
        ach: Interface_Check

        Return
        -------
        num: int

        Description
        -----------
        Determines the first component which brings a given name, or short name for a complex type entity <num0> is the very first record of this entity <num> is given the last nextnamedforcomplex, starts at zero it is returned as the newly found number hence, in the normal case, nextnamedforcomplex starts by num0 if <num> is zero, else by nextforcomplex(num) if the alphabetic order is not respected, it restarts from num0 and loops on nextforcomplex until finding <name> in case of 'non-alphabetic order', <ach> is filled with a warning for this name in case of 'not-found at all', <ach> is filled with a fail, and <num> is returned as zero //! returns true if alphabetic order, false else.

        """
        return _StepData.StepData_StepReaderData_NamedForComplex(self, *args)

    def NextForComplex(self, *args):
        r"""

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

        Return
        -------
        int

        Description
        -----------
        Returns the next 'component' for a complex type entity, of which <num> is already a component (the first one or a next one) returns 0 for a simple type or for the last component.

        """
        return _StepData.StepData_StepReaderData_NextForComplex(self, *args)

    def PrepareHeader(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Works as setentitynumbers but for header: more simple because there are no reference, only sub-lists.

        """
        return _StepData.StepData_StepReaderData_PrepareHeader(self, *args)

    def ReadAny(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check
        descr: StepData_PDescr
        val: Standard_Transient

        Return
        -------
        bool

        Description
        -----------
        Reads parameter <nump> of record <num> into a transient value according to the type of the parameter: named for integer,boolean,logical,enum,real: selectnamed immediate integer,boolean,logical,enum,real: selectint/real text: hasciistring ident: the referenced entity sub-list not processed, see readsub this value is controlled by a parameter descriptor (pdescr), which controls its allowed type and value <ach> is filled if the read parameter does not match its description (the select is nevertheless created if possible) //! warning: val is in out, hence it is possible to predefine a specific selectmember then to fill it. if <val> is null or if the result is not a selectmember, val itself is returned a new ref for a select with a name, <val> must then be a selectnamed.

        """
        return _StepData.StepData_StepReaderData_ReadAny(self, *args)

    def ReadBoolean(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check

        Return
        -------
        flag: bool

        Description
        -----------
        Reads parameter <nump> of record <num> as a boolean return value and check managed as by readreal (demands a boolean enum, i.e. text '.t.' for true or '.f.' for false).

        """
        return _StepData.StepData_StepReaderData_ReadBoolean(self, *args)

    def ReadEnum(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check
        enumtool: StepData_EnumTool

        Return
        -------
        val: int

        Description
        -----------
        Reads parameter <nump> of record <num> as an enumeration (text between dots) and converts it to an integer value, by an enumtool. returns true if ok, false if: this parameter is not enumeration, or is not recognized by the enumtool (with fail).

        """
        return _StepData.StepData_StepReaderData_ReadEnum(self, *args)

    def ReadEnumParam(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check
        text: str

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_StepReaderData_ReadEnumParam(self, *args)

    def ReadField(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check
        descr: StepData_PDescr
        fild: StepData_Field

        Return
        -------
        bool

        Description
        -----------
        Reads parameter <nump> of record <num> into a field, controlled by a parameter descriptor (pdescr), which controls its allowed type(s) and value <ach> is filled if the read parameter does not match its description (but the field is read anyway) if the description is not defined, no control is done returns true when done.

        """
        return _StepData.StepData_StepReaderData_ReadField(self, *args)

    def ReadInteger(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check

        Return
        -------
        val: int

        Description
        -----------
        Reads parameter <nump> of record <num> as a single integer. return value & check managed as by readxy (demands an integer).

        """
        return _StepData.StepData_StepReaderData_ReadInteger(self, *args)

    def ReadList(self, *args):
        r"""

        Parameters
        ----------
        num: int
        ach: Interface_Check
        descr: StepData_ESDescr
        list: StepData_FieldList

        Return
        -------
        bool

        Description
        -----------
        Reads a list of fields controlled by an esdescr.

        """
        return _StepData.StepData_StepReaderData_ReadList(self, *args)

    def ReadLogical(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check

        Return
        -------
        flag: StepData_Logical

        Description
        -----------
        Reads parameter <nump> of record <num> as a logical return value and check managed as by readboolean (demands a logical enum, i.e. text '.t.', '.f.', or '.u.').

        """
        return _StepData.StepData_StepReaderData_ReadLogical(self, *args)

    def ReadReal(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check

        Return
        -------
        val: float

        Description
        -----------
        Reads parameter <nump> of record <num> as a single real value. return value and check managed as by readxy (demands a real).

        """
        return _StepData.StepData_StepReaderData_ReadReal(self, *args)

    def ReadString(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check

        Return
        -------
        val: TCollection_HAsciiString

        Description
        -----------
        Reads parameter <nump> of record <num> as a string (text between quotes, quotes are removed by the read operation) return value and check managed as by readxy (demands a string).

        """
        return _StepData.StepData_StepReaderData_ReadString(self, *args)

    def ReadSub(self, *args):
        r"""

        Parameters
        ----------
        numsub: int
        mess: str
        ach: Interface_Check
        descr: StepData_PDescr
        val: Standard_Transient

        Return
        -------
        int

        Description
        -----------
        Reads the content of a sub-list into a transient: selectnamed, or harray1 of integer,real,string,transient ... recursive call if list of list ... if a sub-list has mixed types, an harray1oftransient is produced, it may contain selectmember intended to be called by readfield the returned status is: negative if failed, 0 if empty. else the kind to be recorded in the field.

        """
        return _StepData.StepData_StepReaderData_ReadSub(self, *args)

    def ReadSubList(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check
        optional: bool (optional, default to Standard_False)
        lenmin: int (optional, default to 0)
        lenmax: int (optional, default to 0)

        Return
        -------
        numsub: int

        Description
        -----------
        Reads parameter <nump> of record <num> as a sub-list (may be typed, see readtypedparameter in this case) returns true if ok. else (not a list), returns false and feeds check with appropriate check if <optional> is true and param is not defined, returns true with <ach> not filled and <numsub> returned as 0 works with sublistnumber with <aslast> false (no specific case for last parameter).

        """
        return _StepData.StepData_StepReaderData_ReadSubList(self, *args)

    def ReadTypedParam(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mustbetyped: bool
        mess: str
        ach: Interface_Check
        typ: str

        Return
        -------
        numr: int
        numrp: int

        Description
        -----------
        Resolves a parameter which can be enclosed in a type def., as type(val). the parameter must then be read normally according its type. parameter to be resolved is <nump> of record <num> <mustbetyped> true demands a typed parameter <mustbetyped> false accepts a non-typed parameter as option mess and ach as usual <numr>,<numrp> are the resolved record and parameter numbers = num,nump if no type, else numrp=1 <typ> returns the recorded type, or empty string remark: a non-typed list is considered as 'non-typed'.

        """
        return _StepData.StepData_StepReaderData_ReadTypedParam(self, *args)

    def ReadXY(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check

        Return
        -------
        X: float
        Y: float

        Description
        -----------
        Reads parameter <nump> of record <num> as a sub-list of two reals x,y. returns true if ok. else, returns false and feeds check with appropriate fails (parameter not a sub-list, not two reals in the sub-list) composed with 'mess' which gives the name of the parameter.

        """
        return _StepData.StepData_StepReaderData_ReadXY(self, *args)

    def ReadXYZ(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        mess: str
        ach: Interface_Check

        Return
        -------
        X: float
        Y: float
        Z: float

        Description
        -----------
        Reads parameter <nump> of record <num> as a sub-list of three reals x,y,z. return value and check managed as by readxy (demands a sub-list of three reals).

        """
        return _StepData.StepData_StepReaderData_ReadXYZ(self, *args)

    def RecordIdent(self, *args):
        r"""

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

        Return
        -------
        int

        Description
        -----------
        Returns record identifier (positive number) if returned ident is not positive: sub-list or scope mark.

        """
        return _StepData.StepData_StepReaderData_RecordIdent(self, *args)

    def RecordType(self, *args):
        r"""

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

        Return
        -------
        TCollection_AsciiString

        Description
        -----------
        Returns record type.

        """
        return _StepData.StepData_StepReaderData_RecordType(self, *args)

    def SetEntityNumbers(self, *args):
        r"""

        Parameters
        ----------
        withmap: bool (optional, default to Standard_True)

        Return
        -------
        None

        Description
        -----------
        Determines reference numbers in entitynumber fields called by prepare from stepreadertool to prepare later using by a stepmodel. this method is attached to stepreaderdata because it needs a massive amount of data accesses to work //! if <withmap> is given false, the basic exploration algorithm is activated, otherwise a map is used as far as it is possible this option can be used only to test this algorithm.

        """
        return _StepData.StepData_StepReaderData_SetEntityNumbers(self, *args)

    def SetRecord(self, *args):
        r"""

        Parameters
        ----------
        num: int
        ident: str
        type: str
        nbpar: int

        Return
        -------
        None

        Description
        -----------
        Fills the fields of a record.

        """
        return _StepData.StepData_StepReaderData_SetRecord(self, *args)

    def SubListNumber(self, *args):
        r"""

        Parameters
        ----------
        num: int
        nump: int
        aslast: bool

        Return
        -------
        int

        Description
        -----------
        Returns sublist numero designated by a parameter (nump) in a record (num), or zero if the parameter does not exist or is not a sublist address. zero too if aslast is true and nump is not for the last parameter.

        """
        return _StepData.StepData_StepReaderData_SubListNumber(self, *args)


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


    __repr__ = _dumps_object

    @methodnotwrapped
    def ReadMember(self):
    	pass

    @methodnotwrapped
    def ReadEntity(self):
    	pass

    __swig_destroy__ = _StepData.delete_StepData_StepReaderData

# Register StepData_StepReaderData in _StepData:
_StepData.StepData_StepReaderData_swigregister(StepData_StepReaderData)
class StepData_StepReaderTool(OCC.Core.Interface.Interface_FileReaderTool):
    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"""

        Parameters
        ----------
        reader: StepData_StepReaderData
        protocol: StepData_Protocol

        Return
        -------
        None

        Description
        -----------
        Creates stepreadertool to work with a stepreaderdata according to a step protocol. defines the readerlib at this time.

        """
        _StepData.StepData_StepReaderTool_swiginit(self, _StepData.new_StepData_StepReaderTool(*args))

    def Prepare(self, *args):
        r"""

        Parameters
        ----------
        optimize: bool (optional, default to Standard_True)

        Return
        -------
        None

        Description
        -----------
        Bounds empty entities to records, uses default recognition provided by readerlib and readermodule. also calls computation of references (setentitynumbers from stepreaderdata) works only on data entities (skips header) <optimize> given false allows to test some internal algorithms which are normally avoided (see also stepreaderdata).

        Parameters
        ----------
        reco: StepData_FileRecognizer
        optimize: bool (optional, default to Standard_True)

        Return
        -------
        None

        Description
        -----------
        Bounds empty entities to records, works with a specific filerecognizer, stored and later used in recognize works only on data entities (skips header) <optimize: same as above.

        """
        return _StepData.StepData_StepReaderTool_Prepare(self, *args)

    def PrepareHeader(self, *args):
        r"""

        Parameters
        ----------
        reco: StepData_FileRecognizer

        Return
        -------
        None

        Description
        -----------
        Bounds empty entities and sub-lists to header records works like prepare + setentitynumbers, but for header (n.b.: in header, no ident and no reference) filerecognizer is to specify entities which are allowed to be defined in the header (not every type can be).

        """
        return _StepData.StepData_StepReaderTool_PrepareHeader(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_StepReaderTool

# Register StepData_StepReaderTool in _StepData:
_StepData.StepData_StepReaderTool_swigregister(StepData_StepReaderTool)
class StepData_StepWriter(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"""

        Parameters
        ----------
        amodel: StepData_StepModel

        Return
        -------
        None

        Description
        -----------
        Creates an empty stepwriter from a stepmodel. the stepmodel provides the number of entities, as identifiers for file.

        """
        _StepData.StepData_StepWriter_swiginit(self, _StepData.new_StepData_StepWriter(*args))

    def AddParam(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Prepares adding a parameter (that is, adds ',' except for first one); normally for internal use; can be used to send a totally empty parameter (with no literal value).

        """
        return _StepData.StepData_StepWriter_AddParam(self, *args)

    def CheckList(self, *args):
        r"""
        Return
        -------
        Interface_CheckIterator

        Description
        -----------
        Returns the check-list, which has received possible checks: for unknown entities, badly loaded ones, null or unknown references.

        """
        return _StepData.StepData_StepWriter_CheckList(self, *args)

    def CloseSub(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Closes a sublist by a ')'.

        """
        return _StepData.StepData_StepWriter_CloseSub(self, *args)

    def Comment(self, *args):
        r"""

        Parameters
        ----------
        mode: bool

        Return
        -------
        None

        Description
        -----------
        Sets a comment mark: if mode is true, begins comment zone, if mode is false, ends comment zone (if one is begun).

        """
        return _StepData.StepData_StepWriter_Comment(self, *args)

    def EndComplex(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sends the end of a complex entity: a simple closed bracket it must be called after sending all the components and before the final call to endentity.

        """
        return _StepData.StepData_StepWriter_EndComplex(self, *args)

    def EndEntity(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sends end of entity (closing bracket plus ';') error if count of opened-closed brackets is not null.

        """
        return _StepData.StepData_StepWriter_EndEntity(self, *args)

    def EndFile(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets end of file; error is endsec was not set.

        """
        return _StepData.StepData_StepWriter_EndFile(self, *args)

    def EndSec(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets end of section; to be done before passing to next one.

        """
        return _StepData.StepData_StepWriter_EndSec(self, *args)

    def FloatWriter(self, *args):
        r"""
        Return
        -------
        Interface_FloatWriter

        Description
        -----------
        Returns the embedded floatwriter, which controls sending reals use this method to access floatwriter in order to consult or change its options (mainformat, formatforrange,zerosuppress), because it is returned as the address of its field.

        """
        return _StepData.StepData_StepWriter_FloatWriter(self, *args)

    def Indent(self, *args):
        r"""

        Parameters
        ----------
        onent: bool

        Return
        -------
        None

        Description
        -----------
        Asks that further indentations will begin at position of entity first opening bracket; else they begin at zero (def) for each sublist level, two more blancks are added at beginning (except for text continuation, which must begin at true zero).

        """
        return _StepData.StepData_StepWriter_Indent(self, *args)

    def IsInScope(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Returns true if an entity identified by its number is in a scope.

        """
        return _StepData.StepData_StepWriter_IsInScope(self, *args)

    def JoinLast(self, *args):
        r"""

        Parameters
        ----------
        newline: bool

        Return
        -------
        None

        Description
        -----------
        Joins current line to last one, only if new length is 72 max if newline is true, a new current line begins; else, current line is set to the last line (once joined) itself an can be completed.

        """
        return _StepData.StepData_StepWriter_JoinLast(self, *args)

    def GetLabelMode(self):
        r"""GetLabelMode(StepData_StepWriter self) -> Standard_Integer"""
        return _StepData.StepData_StepWriter_GetLabelMode(self)

    def SetLabelMode(self, value):
        r"""SetLabelMode(StepData_StepWriter self, Standard_Integer value)"""
        return _StepData.StepData_StepWriter_SetLabelMode(self, value)

    def Line(self, *args):
        r"""

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

        Return
        -------
        opencascade::handle<TCollection_HAsciiString>

        Description
        -----------
        Returns a line given its rank in the file.

        """
        return _StepData.StepData_StepWriter_Line(self, *args)

    def NbLines(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns count of lines.

        """
        return _StepData.StepData_StepWriter_NbLines(self, *args)

    def NewLine(self, *args):
        r"""

        Parameters
        ----------
        evenempty: bool

        Return
        -------
        None

        Description
        -----------
        Flushes current line; if empty, flushes it (defines a new empty line) if evenempty is true; else, skips it.

        """
        return _StepData.StepData_StepWriter_NewLine(self, *args)

    def OpenSub(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Open a sublist by a '('.

        """
        return _StepData.StepData_StepWriter_OpenSub(self, *args)

    def OpenTypedSub(self, *args):
        r"""

        Parameters
        ----------
        subtype: str

        Return
        -------
        None

        Description
        -----------
        Open a sublist with its type then a '('.

        """
        return _StepData.StepData_StepWriter_OpenTypedSub(self, *args)

    def PrintToString(self):
        r"""PrintToString(StepData_StepWriter self) -> std::string"""
        return _StepData.StepData_StepWriter_PrintToString(self)

    def Send(self, *args):
        r"""

        Parameters
        ----------
        val: int

        Return
        -------
        None

        Description
        -----------
        Sends an integer parameter.

        Parameters
        ----------
        val: float

        Return
        -------
        None

        Description
        -----------
        Sends a real parameter (works with floatwriter).

        Parameters
        ----------
        val: str

        Return
        -------
        None

        Description
        -----------
        Sends a text given as string (it will be set between '...').

        Parameters
        ----------
        val: Standard_Transient

        Return
        -------
        None

        Description
        -----------
        Sends a reference to an entity (its identifier with '#') remark 1: a null <val> is interpreted as 'undefined' remark 2: for an hasciistring which is not recorded in the model, it is send as its string content, between quotes.

        """
        return _StepData.StepData_StepWriter_Send(self, *args)

    def SendArrReal(self, *args):
        r"""

        Parameters
        ----------
        anArr: TColStd_HArray1OfReal

        Return
        -------
        None

        Description
        -----------
        Sends an array of real.

        """
        return _StepData.StepData_StepWriter_SendArrReal(self, *args)

    def SendBoolean(self, *args):
        r"""

        Parameters
        ----------
        val: bool

        Return
        -------
        None

        Description
        -----------
        Sends a boolean as .t. for true or .f. for false (it is an useful case of enum, which is built-in).

        """
        return _StepData.StepData_StepWriter_SendBoolean(self, *args)

    def SendComment(self, *args):
        r"""

        Parameters
        ----------
        text: TCollection_HAsciiString

        Return
        -------
        None

        Description
        -----------
        Sends a comment. error if we are not inside a comment zone.

        Parameters
        ----------
        text: str

        Return
        -------
        None

        Description
        -----------
        Same as above but accepts a cstring (ex.: '...' directly).

        """
        return _StepData.StepData_StepWriter_SendComment(self, *args)

    def SendData(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Begins data section; error if endsec was not set.

        """
        return _StepData.StepData_StepWriter_SendData(self, *args)

    def SendDerived(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sends a 'derived' parameter (by '*'). a derived parameter has been inherited from a super-type then redefined as being computed by a function. hence its value in file is senseless.

        """
        return _StepData.StepData_StepWriter_SendDerived(self, *args)

    def SendEndscope(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets an end of scope (on a separate line).

        """
        return _StepData.StepData_StepWriter_SendEndscope(self, *args)

    def SendEntity(self, *args):
        r"""

        Parameters
        ----------
        nument: int
        lib: StepData_WriterLib

        Return
        -------
        None

        Description
        -----------
        Send an entity of the data section. if it corresponds to a scope, also sends the scope information and contained items.

        """
        return _StepData.StepData_StepWriter_SendEntity(self, *args)

    def SendEnum(self, *args):
        r"""

        Parameters
        ----------
        val: str

        Return
        -------
        None

        Description
        -----------
        Sends an enum given by string (literal expression) adds '.' around it if not done remark: val can be computed by class enumtool from stepdata: stepwriter.sendenum (myenum.text(enumval));.

        Parameters
        ----------
        val: str

        Return
        -------
        None

        Description
        -----------
        Sends an enum given by string (literal expression) adds '.' around it if not done.

        """
        return _StepData.StepData_StepWriter_SendEnum(self, *args)

    def SendField(self, *args):
        r"""

        Parameters
        ----------
        fild: StepData_Field
        descr: StepData_PDescr

        Return
        -------
        None

        Description
        -----------
        Sends the content of a field, controlled by its descriptor if the descriptor is not defined, follows the description detained by the field itself.

        """
        return _StepData.StepData_StepWriter_SendField(self, *args)

    def SendHeader(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Begins model header.

        """
        return _StepData.StepData_StepWriter_SendHeader(self, *args)

    def SendIdent(self, *args):
        r"""

        Parameters
        ----------
        ident: int

        Return
        -------
        None

        Description
        -----------
        Begins an entity with an ident plus '=' (at beginning of line) entity ident is its number given by the containing model warning: <ident> must be, either number or label, according labelmode.

        """
        return _StepData.StepData_StepWriter_SendIdent(self, *args)

    def SendList(self, *args):
        r"""

        Parameters
        ----------
        list: StepData_FieldList
        descr: StepData_ESDescr

        Return
        -------
        None

        Description
        -----------
        Send the content of an entity as being a fieldlist controlled by its descriptor. this includes start and end brackets but not the entity type.

        """
        return _StepData.StepData_StepWriter_SendList(self, *args)

    def SendLogical(self, *args):
        r"""

        Parameters
        ----------
        val: StepData_Logical

        Return
        -------
        None

        Description
        -----------
        Sends a logical as .t. or .f. or .u. according its value (it is a standard case of enum for step, and is built-in).

        """
        return _StepData.StepData_StepWriter_SendLogical(self, *args)

    def SendModel(self, *args):
        r"""

        Parameters
        ----------
        protocol: StepData_Protocol
        headeronly: bool (optional, default to Standard_False)

        Return
        -------
        None

        Description
        -----------
        Sends the complete model, included header and data sections works with a writerlib defined through a protocol if <headeronly> is given true, only the header section is sent (used to dump the header of a stepmodel).

        """
        return _StepData.StepData_StepWriter_SendModel(self, *args)

    def SendScope(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets a begin of scope (ends this line).

        """
        return _StepData.StepData_StepWriter_SendScope(self, *args)

    def SendSelect(self, *args):
        r"""

        Parameters
        ----------
        sm: StepData_SelectMember
        descr: StepData_PDescr

        Return
        -------
        None

        Description
        -----------
        Sends a selectmember, which cab be named or not.

        """
        return _StepData.StepData_StepWriter_SendSelect(self, *args)

    def SendString(self, *args):
        r"""

        Parameters
        ----------
        val: str

        Return
        -------
        None

        Description
        -----------
        Sends a string exactly as it is given.

        Parameters
        ----------
        val: str

        Return
        -------
        None

        Description
        -----------
        Sends a string exactly as it is given.

        """
        return _StepData.StepData_StepWriter_SendString(self, *args)

    def SendUndef(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sends an undefined (optional absent) parameter (by '$').

        """
        return _StepData.StepData_StepWriter_SendUndef(self, *args)

    def SetScope(self, *args):
        r"""

        Parameters
        ----------
        numscope: int
        numin: int

        Return
        -------
        None

        Description
        -----------
        Declares the entity number <numscope> to correspond to a scope which contains the entity number <numin>. several calls to the same <numscope> add entities in this scope, in this order. error if <numin> is already declared in the scope warning: the declaration of the scopes is assumed to be consistent, i.e. <numin> is not referenced from outside this scope (not checked here).

        """
        return _StepData.StepData_StepWriter_SetScope(self, *args)

    def StartComplex(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sends the start of a complex entity, which is a simple open bracket (without increasing braket level) it must be called just after sendentity and before sending components, each one begins by startentity.

        """
        return _StepData.StepData_StepWriter_StartComplex(self, *args)

    def StartEntity(self, *args):
        r"""

        Parameters
        ----------
        atype: str

        Return
        -------
        None

        Description
        -----------
        Sets entity's steptype, opens brakets, starts param no to 0 params are separated by comma remark: for a multiple type entity (see express andor clause) startcomplex must be called before sending components, then each 'component' must be sent separately (one call to startentity for each one): the type which precedes is then automatically closed. once all the components have been sent, endcomplex must be called, then and only then endentity.

        """
        return _StepData.StepData_StepWriter_StartEntity(self, *args)

    def GetTypeMode(self):
        r"""GetTypeMode(StepData_StepWriter self) -> Standard_Integer"""
        return _StepData.StepData_StepWriter_GetTypeMode(self)

    def SetTypeMode(self, value):
        r"""SetTypeMode(StepData_StepWriter self, Standard_Integer value)"""
        return _StepData.StepData_StepWriter_SetTypeMode(self, value)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_StepWriter

# Register StepData_StepWriter in _StepData:
_StepData.StepData_StepWriter_swigregister(StepData_StepWriter)
class StepData_WriterLib(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"""

        Parameters
        ----------
        aprotocol: StepData_Protocol

        Return
        -------
        None

        Description
        -----------
        Creates a library which complies with a protocol, that is: same class (criterium isinstance) this creation gets the modules from the global set, those which are bound to the given protocol and its resources.
        Return
        -------
        None

        Description
        -----------
        Creates an empty library: it will later by filled by method addprotocol.

        """
        _StepData.StepData_WriterLib_swiginit(self, _StepData.new_StepData_WriterLib(*args))

    def AddProtocol(self, *args):
        r"""

        Parameters
        ----------
        aprotocol: Standard_Transient

        Return
        -------
        None

        Description
        -----------
        Adds a couple (module-protocol) to the library, given the class of a protocol. takes resources into account. (if <aprotocol> is not of type theprotocol, it is not added).

        """
        return _StepData.StepData_WriterLib_AddProtocol(self, *args)

    def Clear(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Clears the list of modules of a library (can be used to redefine the order of modules before action: clear then refill the library by calls to addprotocol).

        """
        return _StepData.StepData_WriterLib_Clear(self, *args)

    def Module(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_ReadWriteModule>

        Description
        -----------
        Returns the current module in the iteration.

        """
        return _StepData.StepData_WriterLib_Module(self, *args)

    def More(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if there are more modules to iterate on.

        """
        return _StepData.StepData_WriterLib_More(self, *args)

    def Next(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Iterates by getting the next module in the list if there is none, the exception will be raised by value.

        """
        return _StepData.StepData_WriterLib_Next(self, *args)

    def Protocol(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_Protocol>

        Description
        -----------
        Returns the current protocol in the iteration.

        """
        return _StepData.StepData_WriterLib_Protocol(self, *args)

    def Select(self, *args):
        r"""

        Parameters
        ----------
        obj: Standard_Transient
        module: StepData_ReadWriteModule

        Return
        -------
        CN: int

        Description
        -----------
        Selects a module from the library, given an object. returns true if select has succeeded, false else. also returns (as arguments) the selected module and the case number determined by the associated protocol. if select has failed, <module> is null handle and cn is zero. (select can work on any criterium, such as object dynamictype).

        """
        return _StepData.StepData_WriterLib_Select(self, *args)

    def SetComplete(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Sets a library to be defined with the complete global list (all the couples protocol/modules recorded in it).

        """
        return _StepData.StepData_WriterLib_SetComplete(self, *args)

    @staticmethod
    def SetGlobal(*args):
        r"""

        Parameters
        ----------
        amodule: StepData_ReadWriteModule
        aprotocol: StepData_Protocol

        Return
        -------
        None

        Description
        -----------
        Adds a couple (module-protocol) into the global definition set for this class of library.

        """
        return _StepData.StepData_WriterLib_SetGlobal(*args)

    def Start(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Starts iteration on the modules (sets it on the first one).

        """
        return _StepData.StepData_WriterLib_Start(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_WriterLib

# Register StepData_WriterLib in _StepData:
_StepData.StepData_WriterLib_swigregister(StepData_WriterLib)
class StepData_DefaultGeneral(StepData_GeneralModule):
    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"""
        Return
        -------
        None

        Description
        -----------
        Creates a default general module.

        """
        _StepData.StepData_DefaultGeneral_swiginit(self, _StepData.new_StepData_DefaultGeneral(*args))


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_DefaultGeneral

# Register StepData_DefaultGeneral in _StepData:
_StepData.StepData_DefaultGeneral_swigregister(StepData_DefaultGeneral)
class StepData_ECDescr(StepData_EDescr):
    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"""
        Return
        -------
        None

        Description
        -----------
        Creates an ecdescr, empty.

        """
        _StepData.StepData_ECDescr_swiginit(self, _StepData.new_StepData_ECDescr(*args))

    def Add(self, *args):
        r"""

        Parameters
        ----------
        member: StepData_ESDescr

        Return
        -------
        None

        Description
        -----------
        Adds a member warning: members are added in alphabetic order.

        """
        return _StepData.StepData_ECDescr_Add(self, *args)

    def Member(self, *args):
        r"""

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

        Return
        -------
        opencascade::handle<StepData_ESDescr>

        Description
        -----------
        Returns a member from its rank.

        """
        return _StepData.StepData_ECDescr_Member(self, *args)

    def NbMembers(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the count of members.

        """
        return _StepData.StepData_ECDescr_NbMembers(self, *args)

    def TypeList(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HSequenceOfAsciiString>

        Description
        -----------
        Returns the ordered list of types.

        """
        return _StepData.StepData_ECDescr_TypeList(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_ECDescr

# Register StepData_ECDescr in _StepData:
_StepData.StepData_ECDescr_swigregister(StepData_ECDescr)
class StepData_ESDescr(StepData_EDescr):
    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"""

        Parameters
        ----------
        name: str

        Return
        -------
        None

        Description
        -----------
        Creates an esdescr with a type name.

        """
        _StepData.StepData_ESDescr_swiginit(self, _StepData.new_StepData_ESDescr(*args))

    def Base(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_ESDescr>

        Description
        -----------
        Returns the basic esdescr, null if <self> is not derived.

        """
        return _StepData.StepData_ESDescr_Base(self, *args)

    def Field(self, *args):
        r"""

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

        Return
        -------
        opencascade::handle<StepData_PDescr>

        Description
        -----------
        Returns the pdescr for the field <num> (or null).

        """
        return _StepData.StepData_ESDescr_Field(self, *args)

    def IsSub(self, *args):
        r"""

        Parameters
        ----------
        other: StepData_ESDescr

        Return
        -------
        bool

        Description
        -----------
        Tells if <self> is sub-type of (or equal to) another one.

        """
        return _StepData.StepData_ESDescr_IsSub(self, *args)

    def Name(self, *args):
        r"""

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

        Return
        -------
        str

        Description
        -----------
        Returns the name of a field from its rank. empty if outofrange.

        """
        return _StepData.StepData_ESDescr_Name(self, *args)

    def NamedField(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        opencascade::handle<StepData_PDescr>

        Description
        -----------
        Returns the pdescr for the field named <name> (or null).

        """
        return _StepData.StepData_ESDescr_NamedField(self, *args)

    def NbFields(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the count of fields.

        """
        return _StepData.StepData_ESDescr_NbFields(self, *args)

    def Rank(self, *args):
        r"""

        Parameters
        ----------
        name: str

        Return
        -------
        int

        Description
        -----------
        Returns the rank of a field from its name. 0 if unknown.

        """
        return _StepData.StepData_ESDescr_Rank(self, *args)

    def SetBase(self, *args):
        r"""

        Parameters
        ----------
        base: StepData_ESDescr

        Return
        -------
        None

        Description
        -----------
        Sets an esdescr as based on another one hence, if there are inherited fields, the derived esdescr cumulates all them, while the base just records its own ones.

        """
        return _StepData.StepData_ESDescr_SetBase(self, *args)

    def SetField(self, *args):
        r"""

        Parameters
        ----------
        num: int
        name: str
        descr: StepData_PDescr

        Return
        -------
        None

        Description
        -----------
        Sets a pdescr to describe a field a field is designated by its rank and name.

        """
        return _StepData.StepData_ESDescr_SetField(self, *args)

    def SetNbFields(self, *args):
        r"""

        Parameters
        ----------
        nb: int

        Return
        -------
        None

        Description
        -----------
        Sets a new count of fields each one is described by a pdescr.

        """
        return _StepData.StepData_ESDescr_SetNbFields(self, *args)

    def SetSuper(self, *args):
        r"""

        Parameters
        ----------
        super: StepData_ESDescr

        Return
        -------
        None

        Description
        -----------
        Sets an esdescr as 'super-type'. applies an a base (non derived) esdescr.

        """
        return _StepData.StepData_ESDescr_SetSuper(self, *args)

    def StepType(self, *args):
        r"""
        Return
        -------
        TCollection_AsciiString

        Description
        -----------
        Returns the type name as an asciistring.

        """
        return _StepData.StepData_ESDescr_StepType(self, *args)

    def Super(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_ESDescr>

        Description
        -----------
        Returns the super-type esdescr, null if <self> is root.

        """
        return _StepData.StepData_ESDescr_Super(self, *args)

    def TypeName(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        Returns the type name given at creation time.

        """
        return _StepData.StepData_ESDescr_TypeName(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_ESDescr

# Register StepData_ESDescr in _StepData:
_StepData.StepData_ESDescr_swigregister(StepData_ESDescr)
class StepData_FieldList1(StepData_FieldList):
    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"""
        Return
        -------
        None

        Description
        -----------
        Creates a fieldlist of 1 field.

        """
        _StepData.StepData_FieldList1_swiginit(self, _StepData.new_StepData_FieldList1(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_FieldList1

# Register StepData_FieldList1 in _StepData:
_StepData.StepData_FieldList1_swigregister(StepData_FieldList1)
class StepData_FieldListD(StepData_FieldList):
    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"""

        Parameters
        ----------
        nb: int

        Return
        -------
        None

        Description
        -----------
        Creates a fieldlistd of <nb> fields.

        """
        _StepData.StepData_FieldListD_swiginit(self, _StepData.new_StepData_FieldListD(*args))

    def SetNb(self, *args):
        r"""

        Parameters
        ----------
        nb: int

        Return
        -------
        None

        Description
        -----------
        Sets a new count of fields. former contents are lost.

        """
        return _StepData.StepData_FieldListD_SetNb(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_FieldListD

# Register StepData_FieldListD in _StepData:
_StepData.StepData_FieldListD_swigregister(StepData_FieldListD)
class StepData_FieldListN(StepData_FieldList):
    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"""

        Parameters
        ----------
        nb: int

        Return
        -------
        None

        Description
        -----------
        Creates a fieldlistn of <nb> fields.

        """
        _StepData.StepData_FieldListN_swiginit(self, _StepData.new_StepData_FieldListN(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_FieldListN

# Register StepData_FieldListN in _StepData:
_StepData.StepData_FieldListN_swigregister(StepData_FieldListN)
class StepData_FileProtocol(StepData_Protocol):
    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"""
        Return
        -------
        None

        Description
        -----------
        Creates an empty fileprotocol.

        """
        _StepData.StepData_FileProtocol_swiginit(self, _StepData.new_StepData_FileProtocol(*args))

    def Add(self, *args):
        r"""

        Parameters
        ----------
        protocol: StepData_Protocol

        Return
        -------
        None

        Description
        -----------
        Adds a protocol to the definition list of the fileprotocol but ensures that each class of protocol is present only once in this list.

        """
        return _StepData.StepData_FileProtocol_Add(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_FileProtocol

# Register StepData_FileProtocol in _StepData:
_StepData.StepData_FileProtocol_swigregister(StepData_FileProtocol)
class StepData_Plex(StepData_Described):
    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"""

        Parameters
        ----------
        descr: StepData_ECDescr

        Return
        -------
        None

        Description
        -----------
        Creates a plex (empty). the complete creation is made by the ecdescr itself, by calling add.

        """
        _StepData.StepData_Plex_swiginit(self, _StepData.new_StepData_Plex(*args))

    def Add(self, *args):
        r"""

        Parameters
        ----------
        member: StepData_Simple

        Return
        -------
        None

        Description
        -----------
        Adds a member to <self>.

        """
        return _StepData.StepData_Plex_Add(self, *args)

    def ECDescr(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_ECDescr>

        Description
        -----------
        Returns the description as for a plex.

        """
        return _StepData.StepData_Plex_ECDescr(self, *args)

    def Member(self, *args):
        r"""

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

        Return
        -------
        opencascade::handle<StepData_Simple>

        Description
        -----------
        Returns a simple member from its rank.

        """
        return _StepData.StepData_Plex_Member(self, *args)

    def NbMembers(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the count of simple members.

        """
        return _StepData.StepData_Plex_NbMembers(self, *args)

    def TypeList(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HSequenceOfAsciiString>

        Description
        -----------
        Returns the actual list of members types.

        """
        return _StepData.StepData_Plex_TypeList(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_Plex

# Register StepData_Plex in _StepData:
_StepData.StepData_Plex_swigregister(StepData_Plex)
class StepData_SelectInt(StepData_SelectMember):
    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"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _StepData.StepData_SelectInt_swiginit(self, _StepData.new_StepData_SelectInt(*args))


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_SelectInt

# Register StepData_SelectInt in _StepData:
_StepData.StepData_SelectInt_swigregister(StepData_SelectInt)
class StepData_SelectNamed(StepData_SelectMember):
    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"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _StepData.StepData_SelectNamed_swiginit(self, _StepData.new_StepData_SelectNamed(*args))

    def CField(self, *args):
        r"""
        Return
        -------
        StepData_Field

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectNamed_CField(self, *args)

    def Field(self, *args):
        r"""
        Return
        -------
        StepData_Field

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectNamed_Field(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_SelectNamed

# Register StepData_SelectNamed in _StepData:
_StepData.StepData_SelectNamed_swigregister(StepData_SelectNamed)
class StepData_SelectReal(StepData_SelectMember):
    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"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _StepData.StepData_SelectReal_swiginit(self, _StepData.new_StepData_SelectReal(*args))


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_SelectReal

# Register StepData_SelectReal in _StepData:
_StepData.StepData_SelectReal_swigregister(StepData_SelectReal)
class StepData_Simple(StepData_Described):
    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"""

        Parameters
        ----------
        descr: StepData_ESDescr

        Return
        -------
        None

        Description
        -----------
        Creates a simple entity.

        """
        _StepData.StepData_Simple_swiginit(self, _StepData.new_StepData_Simple(*args))

    def CFieldNum(self, *args):
        r"""

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

        Return
        -------
        StepData_Field

        Description
        -----------
        Returns a field from its rank, in order to modify it.

        """
        return _StepData.StepData_Simple_CFieldNum(self, *args)

    def CFields(self, *args):
        r"""
        Return
        -------
        StepData_FieldListN

        Description
        -----------
        Returns the entire field list, read or write.

        """
        return _StepData.StepData_Simple_CFields(self, *args)

    def ESDescr(self, *args):
        r"""
        Return
        -------
        opencascade::handle<StepData_ESDescr>

        Description
        -----------
        Returns description, as for simple.

        """
        return _StepData.StepData_Simple_ESDescr(self, *args)

    def FieldNum(self, *args):
        r"""

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

        Return
        -------
        StepData_Field

        Description
        -----------
        Returns a field from its rank, for read-only use.

        """
        return _StepData.StepData_Simple_FieldNum(self, *args)

    def Fields(self, *args):
        r"""
        Return
        -------
        StepData_FieldListN

        Description
        -----------
        Returns the entire field list, read-only.

        """
        return _StepData.StepData_Simple_Fields(self, *args)

    def NbFields(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the count of fields.

        """
        return _StepData.StepData_Simple_NbFields(self, *args)

    def StepType(self, *args):
        r"""
        Return
        -------
        str

        Description
        -----------
        Returns the recorded steptype (typename of its esdescr).

        """
        return _StepData.StepData_Simple_StepType(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_Simple

# Register StepData_Simple in _StepData:
_StepData.StepData_Simple_swigregister(StepData_Simple)
class StepData_SelectArrReal(StepData_SelectNamed):
    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"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _StepData.StepData_SelectArrReal_swiginit(self, _StepData.new_StepData_SelectArrReal(*args))

    def ArrReal(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HArray1OfReal>

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectArrReal_ArrReal(self, *args)

    def SetArrReal(self, *args):
        r"""

        Parameters
        ----------
        arr: TColStd_HArray1OfReal

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _StepData.StepData_SelectArrReal_SetArrReal(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _StepData.delete_StepData_SelectArrReal

# Register StepData_SelectArrReal in _StepData:
_StepData.StepData_SelectArrReal_swigregister(StepData_SelectArrReal)

@classnotwrapped
class StepData_FreeFormEntity:
	pass

@classnotwrapped
class StepData_UndefinedEntity:
	pass


class StepData_HArray1OfField(StepData_Array1OfField, 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):
        _StepData.StepData_HArray1OfField_swiginit(self, _StepData.new_StepData_HArray1OfField(*args))

    def Array1(self):
        return _StepData.StepData_HArray1OfField_Array1(self)

    def ChangeArray1(self):
        return _StepData.StepData_HArray1OfField_ChangeArray1(self)


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

    __swig_destroy__ = _StepData.delete_StepData_HArray1OfField

# Register StepData_HArray1OfField in _StepData:
_StepData.StepData_HArray1OfField_swigregister(StepData_HArray1OfField)



@deprecated
def stepdata_AddHeaderProtocol(*args):
	return stepdata.AddHeaderProtocol(*args)

@deprecated
def stepdata_HeaderProtocol(*args):
	return stepdata.HeaderProtocol(*args)

@deprecated
def stepdata_Init(*args):
	return stepdata.Init(*args)

@deprecated
def stepdata_Protocol(*args):
	return stepdata.Protocol(*args)

@deprecated
def StepData_GlobalFactors_Intance(*args):
	return StepData_GlobalFactors.Intance(*args)

@deprecated
def StepData_WriterLib_SetGlobal(*args):
	return StepData_WriterLib.SetGlobal(*args)



