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

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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _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 == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _StepData.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args) -> "ptrdiff_t":
        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: "Standard_Failure", method_name: "std::string", class_name: "std::string") -> "void":
    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() -> "opencascade::handle< StepData_Described >":
    return _StepData.Handle_StepData_Described_Create()

def Handle_StepData_Described_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_Described >":
    return _StepData.Handle_StepData_Described_DownCast(t)

def Handle_StepData_Described_IsNull(t: "opencascade::handle< StepData_Described > const &") -> "bool":
    return _StepData.Handle_StepData_Described_IsNull(t)

def Handle_StepData_EDescr_Create() -> "opencascade::handle< StepData_EDescr >":
    return _StepData.Handle_StepData_EDescr_Create()

def Handle_StepData_EDescr_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_EDescr >":
    return _StepData.Handle_StepData_EDescr_DownCast(t)

def Handle_StepData_EDescr_IsNull(t: "opencascade::handle< StepData_EDescr > const &") -> "bool":
    return _StepData.Handle_StepData_EDescr_IsNull(t)

def Handle_StepData_FileRecognizer_Create() -> "opencascade::handle< StepData_FileRecognizer >":
    return _StepData.Handle_StepData_FileRecognizer_Create()

def Handle_StepData_FileRecognizer_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_FileRecognizer >":
    return _StepData.Handle_StepData_FileRecognizer_DownCast(t)

def Handle_StepData_FileRecognizer_IsNull(t: "opencascade::handle< StepData_FileRecognizer > const &") -> "bool":
    return _StepData.Handle_StepData_FileRecognizer_IsNull(t)

def Handle_StepData_GeneralModule_Create() -> "opencascade::handle< StepData_GeneralModule >":
    return _StepData.Handle_StepData_GeneralModule_Create()

def Handle_StepData_GeneralModule_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_GeneralModule >":
    return _StepData.Handle_StepData_GeneralModule_DownCast(t)

def Handle_StepData_GeneralModule_IsNull(t: "opencascade::handle< StepData_GeneralModule > const &") -> "bool":
    return _StepData.Handle_StepData_GeneralModule_IsNull(t)

def Handle_StepData_GlobalNodeOfWriterLib_Create() -> "opencascade::handle< StepData_GlobalNodeOfWriterLib >":
    return _StepData.Handle_StepData_GlobalNodeOfWriterLib_Create()

def Handle_StepData_GlobalNodeOfWriterLib_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_GlobalNodeOfWriterLib >":
    return _StepData.Handle_StepData_GlobalNodeOfWriterLib_DownCast(t)

def Handle_StepData_GlobalNodeOfWriterLib_IsNull(t: "opencascade::handle< StepData_GlobalNodeOfWriterLib > const &") -> "bool":
    return _StepData.Handle_StepData_GlobalNodeOfWriterLib_IsNull(t)

def Handle_StepData_NodeOfWriterLib_Create() -> "opencascade::handle< StepData_NodeOfWriterLib >":
    return _StepData.Handle_StepData_NodeOfWriterLib_Create()

def Handle_StepData_NodeOfWriterLib_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_NodeOfWriterLib >":
    return _StepData.Handle_StepData_NodeOfWriterLib_DownCast(t)

def Handle_StepData_NodeOfWriterLib_IsNull(t: "opencascade::handle< StepData_NodeOfWriterLib > const &") -> "bool":
    return _StepData.Handle_StepData_NodeOfWriterLib_IsNull(t)

def Handle_StepData_PDescr_Create() -> "opencascade::handle< StepData_PDescr >":
    return _StepData.Handle_StepData_PDescr_Create()

def Handle_StepData_PDescr_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_PDescr >":
    return _StepData.Handle_StepData_PDescr_DownCast(t)

def Handle_StepData_PDescr_IsNull(t: "opencascade::handle< StepData_PDescr > const &") -> "bool":
    return _StepData.Handle_StepData_PDescr_IsNull(t)

def Handle_StepData_Protocol_Create() -> "opencascade::handle< StepData_Protocol >":
    return _StepData.Handle_StepData_Protocol_Create()

def Handle_StepData_Protocol_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_Protocol >":
    return _StepData.Handle_StepData_Protocol_DownCast(t)

def Handle_StepData_Protocol_IsNull(t: "opencascade::handle< StepData_Protocol > const &") -> "bool":
    return _StepData.Handle_StepData_Protocol_IsNull(t)

def Handle_StepData_ReadWriteModule_Create() -> "opencascade::handle< StepData_ReadWriteModule >":
    return _StepData.Handle_StepData_ReadWriteModule_Create()

def Handle_StepData_ReadWriteModule_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_ReadWriteModule >":
    return _StepData.Handle_StepData_ReadWriteModule_DownCast(t)

def Handle_StepData_ReadWriteModule_IsNull(t: "opencascade::handle< StepData_ReadWriteModule > const &") -> "bool":
    return _StepData.Handle_StepData_ReadWriteModule_IsNull(t)

def Handle_StepData_SelectMember_Create() -> "opencascade::handle< StepData_SelectMember >":
    return _StepData.Handle_StepData_SelectMember_Create()

def Handle_StepData_SelectMember_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_SelectMember >":
    return _StepData.Handle_StepData_SelectMember_DownCast(t)

def Handle_StepData_SelectMember_IsNull(t: "opencascade::handle< StepData_SelectMember > const &") -> "bool":
    return _StepData.Handle_StepData_SelectMember_IsNull(t)

def Handle_StepData_StepModel_Create() -> "opencascade::handle< StepData_StepModel >":
    return _StepData.Handle_StepData_StepModel_Create()

def Handle_StepData_StepModel_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_StepModel >":
    return _StepData.Handle_StepData_StepModel_DownCast(t)

def Handle_StepData_StepModel_IsNull(t: "opencascade::handle< StepData_StepModel > const &") -> "bool":
    return _StepData.Handle_StepData_StepModel_IsNull(t)

def Handle_StepData_StepReaderData_Create() -> "opencascade::handle< StepData_StepReaderData >":
    return _StepData.Handle_StepData_StepReaderData_Create()

def Handle_StepData_StepReaderData_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_StepReaderData >":
    return _StepData.Handle_StepData_StepReaderData_DownCast(t)

def Handle_StepData_StepReaderData_IsNull(t: "opencascade::handle< StepData_StepReaderData > const &") -> "bool":
    return _StepData.Handle_StepData_StepReaderData_IsNull(t)

def Handle_StepData_DefaultGeneral_Create() -> "opencascade::handle< StepData_DefaultGeneral >":
    return _StepData.Handle_StepData_DefaultGeneral_Create()

def Handle_StepData_DefaultGeneral_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_DefaultGeneral >":
    return _StepData.Handle_StepData_DefaultGeneral_DownCast(t)

def Handle_StepData_DefaultGeneral_IsNull(t: "opencascade::handle< StepData_DefaultGeneral > const &") -> "bool":
    return _StepData.Handle_StepData_DefaultGeneral_IsNull(t)

def Handle_StepData_ECDescr_Create() -> "opencascade::handle< StepData_ECDescr >":
    return _StepData.Handle_StepData_ECDescr_Create()

def Handle_StepData_ECDescr_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_ECDescr >":
    return _StepData.Handle_StepData_ECDescr_DownCast(t)

def Handle_StepData_ECDescr_IsNull(t: "opencascade::handle< StepData_ECDescr > const &") -> "bool":
    return _StepData.Handle_StepData_ECDescr_IsNull(t)

def Handle_StepData_ESDescr_Create() -> "opencascade::handle< StepData_ESDescr >":
    return _StepData.Handle_StepData_ESDescr_Create()

def Handle_StepData_ESDescr_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_ESDescr >":
    return _StepData.Handle_StepData_ESDescr_DownCast(t)

def Handle_StepData_ESDescr_IsNull(t: "opencascade::handle< StepData_ESDescr > const &") -> "bool":
    return _StepData.Handle_StepData_ESDescr_IsNull(t)

def Handle_StepData_FileProtocol_Create() -> "opencascade::handle< StepData_FileProtocol >":
    return _StepData.Handle_StepData_FileProtocol_Create()

def Handle_StepData_FileProtocol_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_FileProtocol >":
    return _StepData.Handle_StepData_FileProtocol_DownCast(t)

def Handle_StepData_FileProtocol_IsNull(t: "opencascade::handle< StepData_FileProtocol > const &") -> "bool":
    return _StepData.Handle_StepData_FileProtocol_IsNull(t)

def Handle_StepData_Plex_Create() -> "opencascade::handle< StepData_Plex >":
    return _StepData.Handle_StepData_Plex_Create()

def Handle_StepData_Plex_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_Plex >":
    return _StepData.Handle_StepData_Plex_DownCast(t)

def Handle_StepData_Plex_IsNull(t: "opencascade::handle< StepData_Plex > const &") -> "bool":
    return _StepData.Handle_StepData_Plex_IsNull(t)

def Handle_StepData_SelectInt_Create() -> "opencascade::handle< StepData_SelectInt >":
    return _StepData.Handle_StepData_SelectInt_Create()

def Handle_StepData_SelectInt_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_SelectInt >":
    return _StepData.Handle_StepData_SelectInt_DownCast(t)

def Handle_StepData_SelectInt_IsNull(t: "opencascade::handle< StepData_SelectInt > const &") -> "bool":
    return _StepData.Handle_StepData_SelectInt_IsNull(t)

def Handle_StepData_SelectNamed_Create() -> "opencascade::handle< StepData_SelectNamed >":
    return _StepData.Handle_StepData_SelectNamed_Create()

def Handle_StepData_SelectNamed_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_SelectNamed >":
    return _StepData.Handle_StepData_SelectNamed_DownCast(t)

def Handle_StepData_SelectNamed_IsNull(t: "opencascade::handle< StepData_SelectNamed > const &") -> "bool":
    return _StepData.Handle_StepData_SelectNamed_IsNull(t)

def Handle_StepData_SelectReal_Create() -> "opencascade::handle< StepData_SelectReal >":
    return _StepData.Handle_StepData_SelectReal_Create()

def Handle_StepData_SelectReal_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_SelectReal >":
    return _StepData.Handle_StepData_SelectReal_DownCast(t)

def Handle_StepData_SelectReal_IsNull(t: "opencascade::handle< StepData_SelectReal > const &") -> "bool":
    return _StepData.Handle_StepData_SelectReal_IsNull(t)

def Handle_StepData_Simple_Create() -> "opencascade::handle< StepData_Simple >":
    return _StepData.Handle_StepData_Simple_Create()

def Handle_StepData_Simple_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_Simple >":
    return _StepData.Handle_StepData_Simple_DownCast(t)

def Handle_StepData_Simple_IsNull(t: "opencascade::handle< StepData_Simple > const &") -> "bool":
    return _StepData.Handle_StepData_Simple_IsNull(t)

def Handle_StepData_SelectArrReal_Create() -> "opencascade::handle< StepData_SelectArrReal >":
    return _StepData.Handle_StepData_SelectArrReal_Create()

def Handle_StepData_SelectArrReal_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_SelectArrReal >":
    return _StepData.Handle_StepData_SelectArrReal_DownCast(t)

def Handle_StepData_SelectArrReal_IsNull(t: "opencascade::handle< StepData_SelectArrReal > const &") -> "bool":
    return _StepData.Handle_StepData_SelectArrReal_IsNull(t)

def Handle_StepData_HArray1OfField_Create() -> "opencascade::handle< StepData_HArray1OfField >":
    return _StepData.Handle_StepData_HArray1OfField_Create()

def Handle_StepData_HArray1OfField_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< StepData_HArray1OfField >":
    return _StepData.Handle_StepData_HArray1OfField_DownCast(t)

def Handle_StepData_HArray1OfField_IsNull(t: "opencascade::handle< StepData_HArray1OfField > const &") -> "bool":
    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) -> "NCollection_Array1< StepData_Field >::iterator":
        return _StepData.StepData_Array1OfField_begin(self)

    def end(self) -> "NCollection_Array1< StepData_Field >::iterator":
        return _StepData.StepData_Array1OfField_end(self)

    def cbegin(self) -> "NCollection_Array1< StepData_Field >::const_iterator":
        return _StepData.StepData_Array1OfField_cbegin(self)

    def cend(self) -> "NCollection_Array1< StepData_Field >::const_iterator":
        return _StepData.StepData_Array1OfField_cend(self)

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

    def Init(self, theValue: "StepData_Field") -> "void":
        return _StepData.StepData_Array1OfField_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _StepData.StepData_Array1OfField_Size(self)

    def Length(self) -> "Standard_Integer":
        return _StepData.StepData_Array1OfField_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _StepData.StepData_Array1OfField_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _StepData.StepData_Array1OfField_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _StepData.StepData_Array1OfField_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _StepData.StepData_Array1OfField_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _StepData.StepData_Array1OfField_IsAllocated(self)

    def Assign(self, theOther: "StepData_Array1OfField") -> "NCollection_Array1< StepData_Field > &":
        return _StepData.StepData_Array1OfField_Assign(self, theOther)

    def Move(self, theOther: "StepData_Array1OfField") -> "NCollection_Array1< StepData_Field > &":
        return _StepData.StepData_Array1OfField_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< StepData_Field > &":
        return _StepData.StepData_Array1OfField_Set(self, *args)

    def First(self) -> "StepData_Field const &":
        return _StepData.StepData_Array1OfField_First(self)

    def ChangeFirst(self) -> "StepData_Field &":
        return _StepData.StepData_Array1OfField_ChangeFirst(self)

    def Last(self) -> "StepData_Field const &":
        return _StepData.StepData_Array1OfField_Last(self)

    def ChangeLast(self) -> "StepData_Field &":
        return _StepData.StepData_Array1OfField_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "StepData_Field const &":
        return _StepData.StepData_Array1OfField_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "StepData_Field &":
        return _StepData.StepData_Array1OfField_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "StepData_Field &":
        return _StepData.StepData_Array1OfField___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "StepData_Field") -> "void":
        return _StepData.StepData_Array1OfField_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        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) -> "void":
        r"""
        Adds a new header protocol to the header definition.

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

        Returns
        -------
        None

        """
        return _StepData.stepdata_AddHeaderProtocol(*args)

    @staticmethod
    def HeaderProtocol(*args) -> "opencascade::handle< StepData_Protocol >":
        r"""
        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.

        Returns
        -------
        opencascade::handle<StepData_Protocol>

        """
        return _StepData.stepdata_HeaderProtocol(*args)

    @staticmethod
    def Init(*args) -> "void":
        r"""
        Prepares general data required to work with this package, which are the protocol and modules to be loaded into libraries.

        Returns
        -------
        None

        """
        return _StepData.stepdata_Init(*args)

    @staticmethod
    def Protocol(*args) -> "opencascade::handle< StepData_Protocol >":
        r"""
        Returns a protocol from stepdata (avoids to create it).

        Returns
        -------
        opencascade::handle<StepData_Protocol>

        """
        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)

def stepdata_AddHeaderProtocol(*args) -> "void":
    r"""
    Adds a new header protocol to the header definition.

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

    Returns
    -------
    None

    """
    return _StepData.stepdata_AddHeaderProtocol(*args)

def stepdata_HeaderProtocol(*args) -> "opencascade::handle< StepData_Protocol >":
    r"""
    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.

    Returns
    -------
    opencascade::handle<StepData_Protocol>

    """
    return _StepData.stepdata_HeaderProtocol(*args)

def stepdata_Init(*args) -> "void":
    r"""
    Prepares general data required to work with this package, which are the protocol and modules to be loaded into libraries.

    Returns
    -------
    None

    """
    return _StepData.stepdata_Init(*args)

def stepdata_Protocol(*args) -> "opencascade::handle< StepData_Protocol >":
    r"""
    Returns a protocol from stepdata (avoids to create it).

    Returns
    -------
    opencascade::handle<StepData_Protocol>

    """
    return _StepData.stepdata_Protocol(*args)

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) -> "opencascade::handle< StepData_Simple >":
        r"""
        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.

        Parameters
        ----------
        steptype: char *

        Returns
        -------
        opencascade::handle<StepData_Simple>

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

    def CField(self, *args) -> "StepData_Field &":
        r"""
        Returns a field from its name; read or write.

        Parameters
        ----------
        name: char *

        Returns
        -------
        StepData_Field

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

    def Check(self, *args) -> "void":
        r"""
        Fills a check by using its description.

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

        Returns
        -------
        None

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

    def Description(self, *args) -> "opencascade::handle< StepData_EDescr >":
        r"""
        Returns the description used to define this entity.

        Returns
        -------
        opencascade::handle<StepData_EDescr>

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

    def Field(self, *args) -> "StepData_Field const &":
        r"""
        Returns a field from its name; read-only.

        Parameters
        ----------
        name: char *

        Returns
        -------
        StepData_Field

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

    def HasField(self, *args) -> "Standard_Boolean":
        r"""
        Tells if a field brings a given name.

        Parameters
        ----------
        name: char *

        Returns
        -------
        bool

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

    def IsComplex(self, *args) -> "Standard_Boolean":
        r"""
        Tells if a described entity is complex.

        Returns
        -------
        bool

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

    def Matches(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Parameters
        ----------
        steptype: char *

        Returns
        -------
        bool

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

    def Shared(self, *args) -> "void":
        r"""
        Fills an entityiterator with entities shared by <self>.

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

        Returns
        -------
        None

        """
        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) -> "Standard_Boolean":
        r"""
        Tells if a edescr is complex (ecdescr) or simple (esdescr).

        Returns
        -------
        bool

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

    def Matches(self, *args) -> "Standard_Boolean":
        r"""
        Tells if a esdescr matches a step type : exact or super type.

        Parameters
        ----------
        steptype: char *

        Returns
        -------
        bool

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

    def NewEntity(self, *args) -> "opencascade::handle< StepData_Described >":
        r"""
        Creates a described entity (i.e. a simple one).

        Returns
        -------
        opencascade::handle<StepData_Described>

        """
        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"""
        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).

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

        Returns
        -------
        None

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

    def AddDefinition(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        term: char *

        Returns
        -------
        None

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

    def IsSet(self, *args) -> "Standard_Boolean":
        r"""
        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'); ... }.

        Returns
        -------
        bool

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

    def MaxValue(self, *args) -> "Standard_Integer":
        r"""
        Returns the maximum integer for a suitable value remark : while values begin at zero, maxvalue is the count of recorded values minus one.

        Returns
        -------
        int

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

    def NullValue(self, *args) -> "Standard_Integer":
        r"""
        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 '$'.

        Returns
        -------
        int

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

    def Optional(self, *args) -> "void":
        r"""
        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).

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

        Returns
        -------
        None

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

    def Text(self, *args) -> "TCollection_AsciiString const &":
        r"""
        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.

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

        Returns
        -------
        TCollection_AsciiString

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

    def Value(self, *args) -> "Standard_Integer":
        r"""
        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: char *

        Returns
        -------
        int
        Same as above but works on an asciistring.

        Parameters
        ----------
        txt: TCollection_AsciiString

        Returns
        -------
        int

        """
        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"""
        Creates a field, empty ('no value defined').

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

        Parameters
        ----------
        other: StepData_Field
        copy: bool,optional
        	default value is Standard_False

        Returns
        -------
        None

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

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

        Returns
        -------
        int

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

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

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        bool

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

    def Clear(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        kind: int,optional
        	default value is 0

        Returns
        -------
        None

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

    def ClearItem(self, *args) -> "void":
        r"""
        Declares an item of the list as undefined (ignored if list not defined as string,entity or any).

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

        Returns
        -------
        None

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

    def CopyFrom(self, *args) -> "void":
        r"""
        Gets the copy of the values of another field.

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

        Returns
        -------
        None

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

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

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        opencascade::handle<Standard_Transient>

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

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

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        int

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

    def EnumText(self, *args) -> "char const *":
        r"""
        No available documentation.

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        char *

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

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

        Returns
        -------
        int

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

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

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        int

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

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

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        bool

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

    def ItemKind(self, *args) -> "Standard_Integer":
        r"""
        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.

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        int

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

    def Kind(self, *args) -> "Standard_Integer":
        r"""
        Returns the kind of the field <type> true (d) : returns only the type itself else, returns the complete kind.

        Parameters
        ----------
        type: bool,optional
        	default value is Standard_True

        Returns
        -------
        int

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

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

        Parameters
        ----------
        index: int,optional
        	default value is 1

        Returns
        -------
        int

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

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

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        StepData_Logical

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

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

        Parameters
        ----------
        index: int,optional
        	default value is 1

        Returns
        -------
        int

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

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

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        float

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

    def Set(self, *args) -> "void":
        r"""
        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).

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

        Returns
        -------
        None

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

    def SetBoolean(self, *args) -> "void":
        r"""
        Sets a boolean value (or predeclares a list as boolean).

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

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

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

        Returns
        -------
        None

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

    def SetDerived(self, *args) -> "void":
        r"""
        Codes a field as derived (no proper value).

        Returns
        -------
        None

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

    def SetEntity(self, *args) -> "void":
        r"""
        Sets an entity value.

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

        Returns
        -------
        None
        Predeclares a list as of entity.

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

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

        Returns
        -------
        None

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

    def SetEnum(self, *args) -> "void":
        r"""
        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
        ----------
        val: int,optional
        	default value is -1
        text: char *,optional
        	default value is 

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

        Parameters
        ----------
        num: int
        val: int
        text: char *,optional
        	default value is 

        Returns
        -------
        None

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

    def SetInt(self, *args) -> "void":
        r"""
        Directly sets the integer value, if its kind matches integer, boolean, logical, or enum (does not change kind).

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

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

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

        Returns
        -------
        None

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

    def SetInteger(self, *args) -> "void":
        r"""
        Sets an integer value (before setlist* declares it as integer).

        Parameters
        ----------
        val: int,optional
        	default value is 0

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

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

        Returns
        -------
        None

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

    def SetList(self, *args) -> "void":
        r"""
        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).

        Parameters
        ----------
        size: int
        first: int,optional
        	default value is 1

        Returns
        -------
        None

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

    def SetList2(self, *args) -> "void":
        r"""
        Declares a field as an homogeneous square list, with initial sizes, and initial lowers.

        Parameters
        ----------
        siz1: int
        siz2: int
        f1: int,optional
        	default value is 1
        f2: int,optional
        	default value is 1

        Returns
        -------
        None

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

    def SetLogical(self, *args) -> "void":
        r"""
        Sets a logical value (or predeclares a list as logical).

        Parameters
        ----------
        val: StepData_Logical,optional
        	default value is StepData_LFalse

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

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

        Returns
        -------
        None

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

    def SetReal(self, *args) -> "void":
        r"""
        Sets a real value (or predeclares a list as real);.

        Parameters
        ----------
        val: float,optional
        	default value is 0.0

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

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

        Returns
        -------
        None

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

    def SetSelectMember(self, *args) -> "void":
        r"""
        Sets a selectmember (for integer,boolean,enum,real,logical) hence, the value of the field is accessed through this member.

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

        Returns
        -------
        None

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

    def SetString(self, *args) -> "void":
        r"""
        Sets a string value (or predeclares a list as string) does not redefine the kind if it is alread string or enum.

        Parameters
        ----------
        val: char *,optional
        	default value is 

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

        Parameters
        ----------
        num: int
        val: char *

        Returns
        -------
        None

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

    def String(self, *args) -> "char const *":
        r"""
        No available documentation.

        Parameters
        ----------
        n1: int,optional
        	default value is 1
        n2: int,optional
        	default value is 1

        Returns
        -------
        char *

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

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

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        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"""
        Creates a fieldlist of 0 field.

        Returns
        -------
        None

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

    def CField(self, *args) -> "StepData_Field &":
        r"""
        Returns the field n0 <num> between 1 and nbfields, in order to modify its content.

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

        Returns
        -------
        StepData_Field

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

    def Field(self, *args) -> "StepData_Field const &":
        r"""
        Returns the field n0 <num> between 1 and nbfields (read only).

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

        Returns
        -------
        StepData_Field

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

    def FillShared(self, *args) -> "void":
        r"""
        Fills an iterator with the entities shared by <self>.

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

        Returns
        -------
        None

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

    def NbFields(self, *args) -> "Standard_Integer":
        r"""
        Returns the count of fields. here, returns 0.

        Returns
        -------
        int

        """
        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) -> "void":
        r"""
        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.

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

        Returns
        -------
        None

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

    def Evaluate(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Parameters
        ----------
        akey: TCollection_AsciiString
        res: Standard_Transient

        Returns
        -------
        bool

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

    def Result(self, *args) -> "opencascade::handle< Standard_Transient >":
        r"""
        Returns result of last recognition (call of evaluate).

        Returns
        -------
        opencascade::handle<Standard_Transient>

        """
        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_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"""
        Creates an empty globalnode, with no next.

        Returns
        -------
        None

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

    def Add(self, *args) -> "void":
        r"""
        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 correspondance.

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

        Returns
        -------
        None

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

    def Module(self, *args) -> "opencascade::handle< StepData_ReadWriteModule > const &":
        r"""
        Returns the module stored in a given globalnode.

        Returns
        -------
        opencascade::handle<StepData_ReadWriteModule>

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

    def Next(self, *args) -> "opencascade::handle< StepData_GlobalNodeOfWriterLib > const &":
        r"""
        Returns the next globalnode. if none is defined, returned value is a null handle.

        Returns
        -------
        opencascade::handle<StepData_GlobalNodeOfWriterLib>

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

    def Protocol(self, *args) -> "opencascade::handle< StepData_Protocol > const &":
        r"""
        Returns the attached protocol stored in a given globalnode.

        Returns
        -------
        opencascade::handle<StepData_Protocol>

        """
        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"""
        Creates an empty node, with no next.

        Returns
        -------
        None

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

    def AddNode(self, *args) -> "void":
        r"""
        Adds a couple (module,protocol), that is, stores it into itself if not yet done, else creates a next node to do it.

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

        Returns
        -------
        None

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

    def Module(self, *args) -> "opencascade::handle< StepData_ReadWriteModule > const &":
        r"""
        Returns the module designated by a precise node.

        Returns
        -------
        opencascade::handle<StepData_ReadWriteModule>

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

    def Next(self, *args) -> "opencascade::handle< StepData_NodeOfWriterLib > const &":
        r"""
        Returns the next node. if none was defined, returned value is a null handle.

        Returns
        -------
        opencascade::handle<StepData_NodeOfWriterLib>

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

    def Protocol(self, *args) -> "opencascade::handle< StepData_Protocol > const &":
        r"""
        Returns the protocol designated by a precise node.

        Returns
        -------
        opencascade::handle<StepData_Protocol>

        """
        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"""
        No available documentation.

        Returns
        -------
        None

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

    def AddArity(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        arity: int,optional
        	default value is 1

        Returns
        -------
        None

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

    def AddEnumDef(self, *args) -> "void":
        r"""
        Adds an enum value as a string.

        Parameters
        ----------
        enumdef: char *

        Returns
        -------
        None

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

    def AddMember(self, *args) -> "void":
        r"""
        Adds a member to a select description.

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

        Returns
        -------
        None

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

    def Arity(self, *args) -> "Standard_Integer":
        r"""
        Returns the arity of <self>.

        Returns
        -------
        int

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

    def Check(self, *args) -> "void":
        r"""
        Semantic check of a field : does it complies with the given description ?.

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

        Returns
        -------
        None

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

    def DescrName(self, *args) -> "char const *":
        r"""
        Returns the description (type name) to match, for a described (else, empty string).

        Returns
        -------
        char *

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

    def EnumMax(self, *args) -> "Standard_Integer":
        r"""
        Returns the maximum integer for a suitable value (count - 1).

        Returns
        -------
        int

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

    def EnumText(self, *args) -> "char const *":
        r"""
        Returns the text which corresponds to a numeric value, between 0 and enummax. it is limited by dots.

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

        Returns
        -------
        char *

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

    def EnumValue(self, *args) -> "Standard_Integer":
        r"""
        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.

        Parameters
        ----------
        name: char *

        Returns
        -------
        int

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

    def FieldName(self, *args) -> "char const *":
        r"""
        No available documentation.

        Returns
        -------
        char *

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

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

        Returns
        -------
        int

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

    def IsBoolean(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is for a boolean value (false,true).

        Returns
        -------
        bool

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

    def IsDerived(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is derived.

        Returns
        -------
        bool

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

    def IsDescr(self, *args) -> "Standard_Boolean":
        r"""
        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).

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

        Returns
        -------
        bool

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

    def IsEntity(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is for an entity, either described or cdl type.

        Returns
        -------
        bool

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

    def IsEnum(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is for an enum value then, call addenumdef ordered from the first one (value 0) managed by an enumtool.

        Returns
        -------
        bool

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

    def IsField(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is a field. else it is a type.

        Returns
        -------
        bool

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

    def IsInteger(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is for an integer.

        Returns
        -------
        bool

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

    def IsLogical(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is for a logical value (false,true,unknown).

        Returns
        -------
        bool

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

    def IsOptional(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is optional.

        Returns
        -------
        bool

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

    def IsReal(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is for a real value.

        Returns
        -------
        bool

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

    def IsSelect(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is for a select.

        Returns
        -------
        bool

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

    def IsString(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is for a string value.

        Returns
        -------
        bool

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

    def IsType(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is for an entity of a given cdl type (early-bnd) (works for <self> + nexts if <self> is a select).

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

        Returns
        -------
        bool

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

    def Member(self, *args) -> "opencascade::handle< StepData_PDescr >":
        r"""
        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.

        Parameters
        ----------
        name: char *

        Returns
        -------
        opencascade::handle<StepData_PDescr>

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

    def Name(self, *args) -> "char const *":
        r"""
        No available documentation.

        Returns
        -------
        char *

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

    def SetArity(self, *args) -> "void":
        r"""
        Directly sets the arity count 0 : simple field 1 : list or array etc 2 : list of list.

        Parameters
        ----------
        arity: int,optional
        	default value is 1

        Returns
        -------
        None

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

    def SetBoolean(self, *args) -> "void":
        r"""
        Sets <self> for a boolean value (false,true).

        Returns
        -------
        None

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

    def SetDerived(self, *args) -> "void":
        r"""
        Sets/unsets <self> to be for a derived field.

        Parameters
        ----------
        der: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

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

    def SetDescr(self, *args) -> "void":
        r"""
        Sets <self> for a described entity, whose description must match the type name <dscnam>.

        Parameters
        ----------
        dscnam: char *

        Returns
        -------
        None

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

    def SetEnum(self, *args) -> "void":
        r"""
        Sets <self> for an enum value then, call addenumdef ordered from the first one (value 0).

        Returns
        -------
        None

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

    def SetField(self, *args) -> "void":
        r"""
        Sets <self> to describe a field of an entity with a name and a rank.

        Parameters
        ----------
        name: char *
        rank: int

        Returns
        -------
        None

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

    def SetFrom(self, *args) -> "void":
        r"""
        Sets <self> as <other> but duplicated hence, some definition may be changed.

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

        Returns
        -------
        None

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

    def SetInteger(self, *args) -> "void":
        r"""
        Sets <self> for an integer value.

        Returns
        -------
        None

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

    def SetLogical(self, *args) -> "void":
        r"""
        Sets <self> for a logical value (false,true,unknown).

        Returns
        -------
        None

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

    def SetMemberName(self, *args) -> "void":
        r"""
        Sets a name for select member. to be used if a member is for an immediate type.

        Parameters
        ----------
        memname: char *

        Returns
        -------
        None

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

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

        Parameters
        ----------
        name: char *

        Returns
        -------
        None

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

    def SetOptional(self, *args) -> "void":
        r"""
        Sets/unsets <self> to accept undefined values.

        Parameters
        ----------
        opt: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

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

    def SetReal(self, *args) -> "void":
        r"""
        Sets <self> for a real value.

        Returns
        -------
        None

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

    def SetSelect(self, *args) -> "void":
        r"""
        Declares this pdescr to be a select, hence to have members <self> itself can be the first member.

        Returns
        -------
        None

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

    def SetString(self, *args) -> "void":
        r"""
        Sets <self> for a string value.

        Returns
        -------
        None

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

    def SetType(self, *args) -> "void":
        r"""
        Sets <self> for an entity which must match a type (early-bound).

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

        Returns
        -------
        None

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

    def Simple(self, *args) -> "opencascade::handle< StepData_PDescr >":
        r"""
        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] ...

        Returns
        -------
        opencascade::handle<StepData_PDescr>

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

    def Type(self, *args) -> "opencascade::handle< Standard_Type >":
        r"""
        Returns the type to match (iskind), for a cdl entity (else, null handle).

        Returns
        -------
        opencascade::handle<Standard_Type>

        """
        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"""
        No available documentation.

        Returns
        -------
        None

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

    def AddBasicDescr(self, *args) -> "void":
        r"""
        Records an esdescr, intended to build complex descriptions.

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

        Returns
        -------
        None

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

    def AddDescr(self, *args) -> "void":
        r"""
        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.

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

        Returns
        -------
        None

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

    def AddPDescr(self, *args) -> "void":
        r"""
        Records an pdescr.

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

        Returns
        -------
        None

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

    def BasicDescr(self, *args) -> "opencascade::handle< StepData_EDescr >":
        r"""
        Returns a basic description according to its name <anylevel> true (d) : for <self> and its resources <anylevel> false : for <self> only.

        Parameters
        ----------
        name: char *
        anylevel: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<StepData_EDescr>

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

    def Descr(self, *args) -> "opencascade::handle< StepData_EDescr >":
        r"""
        Returns the description attached to a case number, or null.

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

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

        Parameters
        ----------
        name: char *
        anylevel: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<StepData_EDescr>

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

    def DescrNumber(self, *args) -> "Standard_Integer":
        r"""
        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.

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

        Returns
        -------
        int

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

    def ECDescr(self, *args) -> "opencascade::handle< StepData_ECDescr >":
        r"""
        Returns a complex description according to list of names <anylevel> true (d) : for <self> and its resources <anylevel> false : for <self> only.

        Parameters
        ----------
        names: TColStd_SequenceOfAsciiString
        anylevel: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<StepData_ECDescr>

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

    def ESDescr(self, *args) -> "opencascade::handle< StepData_ESDescr >":
        r"""
        Idem as descr but cast to simple description.

        Parameters
        ----------
        name: char *
        anylevel: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<StepData_ESDescr>

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

    def HasDescr(self, *args) -> "Standard_Boolean":
        r"""
        Tells if a protocol brings at least one esdescr, i.e. if it defines at least one entity description by esdescr mechanism.

        Returns
        -------
        bool

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

    def PDescr(self, *args) -> "opencascade::handle< StepData_PDescr >":
        r"""
        Returns a parameter description according to its name <anylevel> true (d) : for <self> and its resources <anylevel> false : for <self> only.

        Parameters
        ----------
        name: char *
        anylevel: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<StepData_PDescr>

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

    def SchemaName(self, *args) -> "char const *":
        r"""
        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.

        Returns
        -------
        char *

        """
        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) -> "Standard_Integer":
        r"""
        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
        ----------
        atype: TCollection_AsciiString

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

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

        Returns
        -------
        int

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

    def ComplexType(self, *args) -> "Standard_Boolean":
        r"""
        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.

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

        Returns
        -------
        bool

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

    def IsComplex(self, *args) -> "Standard_Boolean":
        r"""
        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.

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

        Returns
        -------
        bool

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

    def ReadStep(self, *args) -> "void":
        r"""
        Specific read function. works with stepreaderdata.

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

        Returns
        -------
        None

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

    def ShortType(self, *args) -> "TCollection_AsciiString":
        r"""
        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.

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

        Returns
        -------
        TCollection_AsciiString

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

    def StepType(self, *args) -> "TCollection_AsciiString const &":
        r"""
        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).

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

        Returns
        -------
        TCollection_AsciiString

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

    def WriteStep(self, *args) -> "void":
        r"""
        Write function, switched by casenum.

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

        Returns
        -------
        None

        """
        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"""
        No available documentation.

        Returns
        -------
        None

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

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

        Returns
        -------
        bool

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

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

        Returns
        -------
        int

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

    def EnumText(self, *args) -> "char const *":
        r"""
        No available documentation.

        Returns
        -------
        char *

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

    def HasName(self, *args) -> "Standard_Boolean":
        r"""
        Tells if a selectmember has a name. default is false.

        Returns
        -------
        bool

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

    def Int(self, *args) -> "Standard_Integer":
        r"""
        This internal method gives access to a value implemented by an integer (to read it).

        Returns
        -------
        int

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

    def Integer(self, *args) -> "Standard_Integer":
        r"""
        Gets the value as an integer.

        Returns
        -------
        int

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

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

        Returns
        -------
        int

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

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

        Returns
        -------
        StepData_Logical

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

    def Matches(self, *args) -> "Standard_Boolean":
        r"""
        Tells if the name of a selectmember matches a given one by default, compares the strings, can be redefined (optimised).

        Parameters
        ----------
        name: char *

        Returns
        -------
        bool

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

    def Name(self, *args) -> "char const *":
        r"""
        Returns the name of a selectmember. default is empty.

        Returns
        -------
        char *

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

    def ParamType(self, *args) -> "Interface_ParamType":
        r"""
        Returns the kind of the selectmember, under the form of an enum paramtype.

        Returns
        -------
        Interface_ParamType

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

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

        Returns
        -------
        float

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

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

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

        Returns
        -------
        None

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

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

        Parameters
        ----------
        val: int
        text: char *,optional
        	default value is 

        Returns
        -------
        None

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

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

        Parameters
        ----------
        val: int
        text: char *

        Returns
        -------
        None

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

    def SetInt(self, *args) -> "void":
        r"""
        This internal method gives access to a value implemented by an integer (to set it).

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

        Returns
        -------
        None

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

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

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

        Returns
        -------
        None

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

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

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

        Returns
        -------
        None

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

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

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

        Returns
        -------
        None

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

    def SetName(self, *args) -> "Standard_Boolean":
        r"""
        Sets the name of a selectmember, returns true if done, false if no name is allowed default does nothing and returns false.

        Parameters
        ----------
        name: char *

        Returns
        -------
        bool

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

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

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

        Returns
        -------
        None

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

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

        Parameters
        ----------
        val: char *

        Returns
        -------
        None

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

    def String(self, *args) -> "char const *":
        r"""
        No available documentation.

        Returns
        -------
        char *

        """
        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) -> "Standard_Boolean":
        r"""
        No available documentation.

        Returns
        -------
        bool

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

    def CaseMem(self, *args) -> "Standard_Integer":
        r"""
        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.

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

        Returns
        -------
        int

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

    def CaseMember(self, *args) -> "Standard_Integer":
        r"""
        Returns the type of the stored selectmember, or zero if it is null or entity. calls the method casemem on value.

        Returns
        -------
        int

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

    def CaseNum(self, *args) -> "Standard_Integer":
        r"""
        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.

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

        Returns
        -------
        int

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

    def CaseNumber(self, *args) -> "Standard_Integer":
        r"""
        Recognizes the type of the stored entity, or zero if it is null or selectmember. calls the first method casenum on value.

        Returns
        -------
        int

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

    def Description(self, *args) -> "opencascade::handle< StepData_PDescr >":
        r"""
        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.

        Returns
        -------
        opencascade::handle<StepData_PDescr>

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

    def Int(self, *args) -> "Standard_Integer":
        r"""
        This internal method gives access to a value implemented by an integer (to read it).

        Returns
        -------
        int

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

    def Integer(self, *args) -> "Standard_Integer":
        r"""
        Gets the value as an integer.

        Returns
        -------
        int

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

    def IsNull(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if there is no stored entity (i.e. it is null).

        Returns
        -------
        bool

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

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

        Returns
        -------
        StepData_Logical

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

    def Matches(self, *args) -> "Standard_Boolean":
        r"""
        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.

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

        Returns
        -------
        bool

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

    def Member(self, *args) -> "opencascade::handle< StepData_SelectMember >":
        r"""
        Returns value as a selectmember. null if not a selectmember.

        Returns
        -------
        opencascade::handle<StepData_SelectMember>

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

    def NewMember(self, *args) -> "opencascade::handle< StepData_SelectMember >":
        r"""
        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.

        Returns
        -------
        opencascade::handle<StepData_SelectMember>

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

    def Nullify(self, *args) -> "void":
        r"""
        Nullifies the stored entity.

        Returns
        -------
        None

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

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

        Returns
        -------
        float

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

    def SelectName(self, *args) -> "char const *":
        r"""
        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.

        Returns
        -------
        char *

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

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

        Parameters
        ----------
        val: bool
        name: char *,optional
        	default value is 

        Returns
        -------
        None

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

    def SetInt(self, *args) -> "void":
        r"""
        This internal method gives access to a value implemented by an integer (to set it) : a selectmember must already be there !.

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

        Returns
        -------
        None

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

    def SetInteger(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        val: int
        name: char *,optional
        	default value is 

        Returns
        -------
        None

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

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

        Parameters
        ----------
        val: StepData_Logical
        name: char *,optional
        	default value is 

        Returns
        -------
        None

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

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

        Parameters
        ----------
        val: float
        name: char *,optional
        	default value is 

        Returns
        -------
        None

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

    def SetValue(self, *args) -> "void":
        r"""
        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.

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

        Returns
        -------
        None

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

    def Type(self, *args) -> "opencascade::handle< Standard_Type >":
        r"""
        Returns the effective (dynamic) type of the stored entity if it is null, returns type(transient).

        Returns
        -------
        opencascade::handle<Standard_Type>

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

    def Value(self, *args) -> "opencascade::handle< Standard_Transient > const &":
        r"""
        Returns the stored entity. can be used to define specific read methods (see above).

        Returns
        -------
        opencascade::handle<Standard_Transient>

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

        Parameters
        ----------
        amodel: StepData_StepModel
        protocol: StepData_Protocol
        mode: int,optional
        	default value is 0

        Returns
        -------
        None

        """
        _StepData.StepData_StepDumper_swiginit(self, _StepData.new_StepData_StepDumper(*args))

    def StepWriter(self, *args) -> "StepData_StepWriter &":
        r"""
        Gives an access to the tool which is used to work : this allow to acts on some parameters : floating format, scopes ...

        Returns
        -------
        StepData_StepWriter

        """
        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"""
        Creates an empty step model with an empty header.

        Returns
        -------
        None

        """
        _StepData.StepData_StepModel_swiginit(self, _StepData.new_StepData_StepModel(*args))

    def AddHeaderEntity(self, *args) -> "void":
        r"""
        Adds an entity to the header.

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

        Returns
        -------
        None

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

    def Entity(self, *args) -> "opencascade::handle< Standard_Transient >":
        r"""
        Returns entity given its rank. same as interfaceentity, but with a shorter name.

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

        Returns
        -------
        opencascade::handle<Standard_Transient>

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

    def HasHeaderEntity(self, *args) -> "Standard_Boolean":
        r"""
        Says if a header entity has a specifed type.

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

        Returns
        -------
        bool

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

    def Header(self, *args) -> "Interface_EntityIterator":
        r"""
        Returns header entities under the form of an iterator.

        Returns
        -------
        Interface_EntityIterator

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

    def HeaderEntity(self, *args) -> "opencascade::handle< Standard_Transient >":
        r"""
        Returns header entity with specified type, if there is.

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

        Returns
        -------
        opencascade::handle<Standard_Transient>

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

    def IdentLabel(self, *args) -> "Standard_Integer":
        r"""
        Returns the label ident attached to an entity, 0 if not in me.

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

        Returns
        -------
        int

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

    def SetIdentLabel(self, *args) -> "void":
        r"""
        Attaches an ident to an entity to produce a label (does nothing if <ent> is not in <self>).

        Parameters
        ----------
        ent: Standard_Transient
        ident: int

        Returns
        -------
        None

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

    def SetSourceCodePage(self, *args) -> "void":
        r"""
        Return the encoding of step file for converting names into unicode.

        Parameters
        ----------
        theCode: Resource_FormatType

        Returns
        -------
        None

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

    def SourceCodePage(self, *args) -> "Resource_FormatType":
        r"""
        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.

        Returns
        -------
        Resource_FormatType

        """
        return _StepData.StepData_StepModel_SourceCodePage(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"""
        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.

        Parameters
        ----------
        nbheader: int
        nbtotal: int
        nbpar: int
        theSourceCodePage: Resource_FormatType,optional
        	default value is Resource_FormatType_UTF8

        Returns
        -------
        None

        """
        _StepData.StepData_StepReaderData_swiginit(self, _StepData.new_StepData_StepReaderData(*args))

    def AddStepParam(self, *args) -> "void":
        r"""
        Fills the fields of a parameter of a record. this is a variant of addparam, adapted to step (optimized for specific values).

        Parameters
        ----------
        num: int
        aval: char *
        atype: Interface_ParamType
        nument: int,optional
        	default value is 0

        Returns
        -------
        None

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

    def CType(self, *args) -> "char const *":
        r"""
        Returns record type as a cstring was c++ : return const.

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

        Returns
        -------
        char *

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

    def CheckDerived(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check
        errstat: bool,optional
        	default value is Standard_False

        Returns
        -------
        bool

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

    def CheckNbParams(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Parameters
        ----------
        num: int
        nbreq: int
        ach: Interface_Check
        mess: char *,optional
        	default value is 

        Returns
        -------
        bool

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

    def ComplexType(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        num: int
        types: TColStd_SequenceOfAsciiString

        Returns
        -------
        None

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

    def FailEnumValue(self, *args) -> "void":
        r"""
        Fills a check with a fail message if enumeration value does match parameter definition just a help to centralize message definitions.

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check

        Returns
        -------
        None

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

    def FindNextHeaderRecord(self, *args) -> "Standard_Integer":
        r"""
        Determine first suitable record of header works as findnextrecord, but treats only header records.

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

        Returns
        -------
        int

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

    def GlobalCheck(self, *args) -> "opencascade::handle< Interface_Check > const":
        r"""
        Returns the global check. it can record fail messages about undefined references (detected by setentitynumbers).

        Returns
        -------
        opencascade::handle<Interface_Check>

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

    def IsComplex(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if <num> corresponds to a complex type entity (as can be defined by andor express clause).

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

        Returns
        -------
        bool

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

    def NamedForComplex(self, *args) -> "Standard_Boolean":
        r"""
        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
        ----------
        name: char *
        num0: int
        ach: Interface_Check

        Returns
        -------
        num: int
        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.

        Parameters
        ----------
        theName: char *
        theShortName: char *
        num0: int
        ach: Interface_Check

        Returns
        -------
        num: int

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

    def NextForComplex(self, *args) -> "Standard_Integer":
        r"""
        Returns the next 'componant' for a complex type entity, of which <num> is already a componant (the first one or a next one) returns 0 for a simple type or for the last componant.

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

        Returns
        -------
        int

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

    def PrepareHeader(self, *args) -> "void":
        r"""
        Works as setentitynumbers but for header : more simple because there are no reference, only sub-lists.

        Returns
        -------
        None

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

    def ReadAny(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check
        descr: StepData_PDescr
        val: Standard_Transient

        Returns
        -------
        bool

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

    def ReadBoolean(self, *args) -> "Standard_Boolean":
        r"""
        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).

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check

        Returns
        -------
        flag: bool

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

    def ReadEnum(self, *args) -> "Standard_Boolean":
        r"""
        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).

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check
        enumtool: StepData_EnumTool

        Returns
        -------
        val: int

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

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

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check
        text: char *

        Returns
        -------
        bool

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

    def ReadField(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check
        descr: StepData_PDescr
        fild: StepData_Field

        Returns
        -------
        bool

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

    def ReadInteger(self, *args) -> "Standard_Boolean":
        r"""
        Reads parameter <nump> of record <num> as a single integer. return value & check managed as by readxy (demands an integer).

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check

        Returns
        -------
        val: int

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

    def ReadList(self, *args) -> "Standard_Boolean":
        r"""
        Reads a list of fields controlled by an esdescr.

        Parameters
        ----------
        num: int
        ach: Interface_Check
        descr: StepData_ESDescr
        list: StepData_FieldList

        Returns
        -------
        bool

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

    def ReadLogical(self, *args) -> "Standard_Boolean":
        r"""
        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.').

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check
        flag: StepData_Logical

        Returns
        -------
        bool

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

    def ReadReal(self, *args) -> "Standard_Boolean":
        r"""
        Reads parameter <nump> of record <num> as a single real value. return value and check managed as by readxy (demands a real).

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check

        Returns
        -------
        val: float

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

    def ReadString(self, *args) -> "Standard_Boolean":
        r"""
        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).

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check
        val: TCollection_HAsciiString

        Returns
        -------
        bool

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

    def ReadSub(self, *args) -> "Standard_Integer":
        r"""
        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.

        Parameters
        ----------
        numsub: int
        mess: char *
        ach: Interface_Check
        descr: StepData_PDescr
        val: Standard_Transient

        Returns
        -------
        int

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

    def ReadSubList(self, *args) -> "Standard_Boolean":
        r"""
        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).

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check
        optional: bool,optional
        	default value is Standard_False
        lenmin: int,optional
        	default value is 0
        lenmax: int,optional
        	default value is 0

        Returns
        -------
        numsub: int

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

    def ReadTypedParam(self, *args) -> "Standard_Boolean":
        r"""
        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'.

        Parameters
        ----------
        num: int
        nump: int
        mustbetyped: bool
        mess: char *
        ach: Interface_Check
        typ: TCollection_AsciiString

        Returns
        -------
        numr: int
        numrp: int

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

    def ReadXY(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check

        Returns
        -------
        X: float
        Y: float

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

    def ReadXYZ(self, *args) -> "Standard_Boolean":
        r"""
        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).

        Parameters
        ----------
        num: int
        nump: int
        mess: char *
        ach: Interface_Check

        Returns
        -------
        X: float
        Y: float
        Z: float

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

    def RecordIdent(self, *args) -> "Standard_Integer":
        r"""
        Returns record identifier (positive number) if returned ident is not positive : sub-list or scope mark.

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

        Returns
        -------
        int

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

    def RecordType(self, *args) -> "TCollection_AsciiString const &":
        r"""
        Returns record type.

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

        Returns
        -------
        TCollection_AsciiString

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

    def SetEntityNumbers(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        withmap: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

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

    def SetRecord(self, *args) -> "void":
        r"""
        Fills the fields of a record.

        Parameters
        ----------
        num: int
        ident: char *
        type: char *
        nbpar: int

        Returns
        -------
        None

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

    def SubListNumber(self, *args) -> "Standard_Integer":
        r"""
        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.

        Parameters
        ----------
        num: int
        nump: int
        aslast: bool

        Returns
        -------
        int

        """
        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"""
        Creates stepreadertool to work with a stepreaderdata according to a step protocol. defines the readerlib at this time.

        Parameters
        ----------
        reader: StepData_StepReaderData
        protocol: StepData_Protocol

        Returns
        -------
        None

        """
        _StepData.StepData_StepReaderTool_swiginit(self, _StepData.new_StepData_StepReaderTool(*args))

    def Prepare(self, *args) -> "void":
        r"""
        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
        ----------
        optimize: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        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.

        Parameters
        ----------
        reco: StepData_FileRecognizer
        optimize: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

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

    def PrepareHeader(self, *args) -> "void":
        r"""
        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).

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

        Returns
        -------
        None

        """
        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"""
        Creates an empty stepwriter from a stepmodel. the stepmodel provides the number of entities, as identifiers for file.

        Parameters
        ----------
        amodel: StepData_StepModel

        Returns
        -------
        None

        """
        _StepData.StepData_StepWriter_swiginit(self, _StepData.new_StepData_StepWriter(*args))

    def AddParam(self, *args) -> "void":
        r"""
        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 litteral value).

        Returns
        -------
        None

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

    def CheckList(self, *args) -> "Interface_CheckIterator":
        r"""
        Returns the check-list, which has received possible checks : for unknown entities, badly loaded ones, null or unknown references.

        Returns
        -------
        Interface_CheckIterator

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

    def CloseSub(self, *args) -> "void":
        r"""
        Closes a sublist by a ')'.

        Returns
        -------
        None

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

    def Comment(self, *args) -> "void":
        r"""
        Sets a comment mark : if mode is true, begins comment zone, if mode is false, ends comment zone (if one is begun).

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

        Returns
        -------
        None

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

    def EndComplex(self, *args) -> "void":
        r"""
        Sends the end of a complex entity : a simple closed bracket it must be called after sending all the componants and before the final call to endentity.

        Returns
        -------
        None

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

    def EndEntity(self, *args) -> "void":
        r"""
        Sends end of entity (closing bracket plus ';') error if count of opened-closed brackets is not null.

        Returns
        -------
        None

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

    def EndFile(self, *args) -> "void":
        r"""
        Sets end of file; error is endsec was not set.

        Returns
        -------
        None

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

    def EndSec(self, *args) -> "void":
        r"""
        Sets end of section; to be done before passing to next one.

        Returns
        -------
        None

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

    def FloatWriter(self, *args) -> "Interface_FloatWriter &":
        r"""
        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.

        Returns
        -------
        Interface_FloatWriter

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

    def Indent(self, *args) -> "void":
        r"""
        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).

        Parameters
        ----------
        onent: bool

        Returns
        -------
        None

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

    def IsInScope(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if an entity identified by its number is in a scope.

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

        Returns
        -------
        bool

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

    def JoinLast(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        newline: bool

        Returns
        -------
        None

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

    def GetLabelMode(self) -> "Standard_Integer":
        r"""GetLabelMode(StepData_StepWriter self) -> Standard_Integer"""
        return _StepData.StepData_StepWriter_GetLabelMode(self)

    def SetLabelMode(self, value: "Standard_Integer") -> "void":
        r"""SetLabelMode(StepData_StepWriter self, Standard_Integer value)"""
        return _StepData.StepData_StepWriter_SetLabelMode(self, value)

    def Line(self, *args) -> "opencascade::handle< TCollection_HAsciiString >":
        r"""
        Returns a line given its rank in the file.

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

        Returns
        -------
        opencascade::handle<TCollection_HAsciiString>

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

    def NbLines(self, *args) -> "Standard_Integer":
        r"""
        Returns count of lines.

        Returns
        -------
        int

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

    def NewLine(self, *args) -> "void":
        r"""
        Flushes current line; if empty, flushes it (defines a new empty line) if evenempty is true; else, skips it.

        Parameters
        ----------
        evenempty: bool

        Returns
        -------
        None

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

    def OpenSub(self, *args) -> "void":
        r"""
        Open a sublist by a '('.

        Returns
        -------
        None

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

    def OpenTypedSub(self, *args) -> "void":
        r"""
        Open a sublist with its type then a '('.

        Parameters
        ----------
        subtype: char *

        Returns
        -------
        None

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

    def PrintToString(self) -> "std::string":
        r"""PrintToString(StepData_StepWriter self) -> std::string"""
        return _StepData.StepData_StepWriter_PrintToString(self)

    def Send(self, *args) -> "void":
        r"""
        Sends an integer parameter.

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

        Returns
        -------
        None
        Sends a real parameter (wroks with floatwriter).

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

        Returns
        -------
        None
        Sends a text given as string (it will be set between '...').

        Parameters
        ----------
        val: TCollection_AsciiString

        Returns
        -------
        None
        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.

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

        Returns
        -------
        None

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

    def SendArrReal(self, *args) -> "void":
        r"""
        Sends an array of real.

        Parameters
        ----------
        anArr: TColStd_HArray1OfReal

        Returns
        -------
        None

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

    def SendBoolean(self, *args) -> "void":
        r"""
        Sends a boolean as .t. for true or .f. for false (it is an useful case of enum, which is built-in).

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

        Returns
        -------
        None

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

    def SendComment(self, *args) -> "void":
        r"""
        Sends a comment. error if we are not inside a comment zone.

        Parameters
        ----------
        text: TCollection_HAsciiString

        Returns
        -------
        None
        Same as above but accepts a cstring (ex.: '...' directly).

        Parameters
        ----------
        text: char *

        Returns
        -------
        None

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

    def SendData(self, *args) -> "void":
        r"""
        Begins data section; error if endsec was not set.

        Returns
        -------
        None

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

    def SendDerived(self, *args) -> "void":
        r"""
        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.

        Returns
        -------
        None

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

    def SendEndscope(self, *args) -> "void":
        r"""
        Sets an end of scope (on a separate line).

        Returns
        -------
        None

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

    def SendEntity(self, *args) -> "void":
        r"""
        Send an entity of the data section. if it corresponds to a scope, also sends the scope informations and contained items.

        Parameters
        ----------
        nument: int
        lib: StepData_WriterLib

        Returns
        -------
        None

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

    def SendEnum(self, *args) -> "void":
        r"""
        Sends an enum given by string (litteral expression) adds '.' around it if not done remark : val can be computed by class enumtool from stepdata: stepwriter.sendenum (myenum.text(enumval));.

        Parameters
        ----------
        val: TCollection_AsciiString

        Returns
        -------
        None
        Sends an enum given by string (litteral expression) adds '.' around it if not done.

        Parameters
        ----------
        val: char *

        Returns
        -------
        None

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

    def SendField(self, *args) -> "void":
        r"""
        Sends the content of a field, controlled by its descriptor if the descriptor is not defined, follows the description detained by the field itself.

        Parameters
        ----------
        fild: StepData_Field
        descr: StepData_PDescr

        Returns
        -------
        None

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

    def SendHeader(self, *args) -> "void":
        r"""
        Begins model header.

        Returns
        -------
        None

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

    def SendIdent(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        ident: int

        Returns
        -------
        None

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

    def SendList(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        list: StepData_FieldList
        descr: StepData_ESDescr

        Returns
        -------
        None

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

    def SendLogical(self, *args) -> "void":
        r"""
        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).

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

        Returns
        -------
        None

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

    def SendModel(self, *args) -> "void":
        r"""
        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).

        Parameters
        ----------
        protocol: StepData_Protocol
        headeronly: bool,optional
        	default value is Standard_False

        Returns
        -------
        None

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

    def SendScope(self, *args) -> "void":
        r"""
        Sets a begin of scope (ends this line).

        Returns
        -------
        None

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

    def SendSelect(self, *args) -> "void":
        r"""
        Sends a selectmember, which cab be named or not.

        Parameters
        ----------
        sm: StepData_SelectMember
        descr: StepData_PDescr

        Returns
        -------
        None

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

    def SendString(self, *args) -> "void":
        r"""
        Sends a string exactly as it is given.

        Parameters
        ----------
        val: TCollection_AsciiString

        Returns
        -------
        None
        Sends a string exactly as it is given.

        Parameters
        ----------
        val: char *

        Returns
        -------
        None

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

    def SendUndef(self, *args) -> "void":
        r"""
        Sends an undefined (optionnal absent) parameter (by '$').

        Returns
        -------
        None

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

    def SetScope(self, *args) -> "void":
        r"""
        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).

        Parameters
        ----------
        numscope: int
        numin: int

        Returns
        -------
        None

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

    def StartComplex(self, *args) -> "void":
        r"""
        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 componants, each one begins by startentity.

        Returns
        -------
        None

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

    def StartEntity(self, *args) -> "void":
        r"""
        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 componants, then each 'componant' must be send separately (one call to startentity for each one) : the type which preceeds is then automaticaly closed. once all the componants have been sent, endcomplex must be called, then and only then endentity.

        Parameters
        ----------
        atype: TCollection_AsciiString

        Returns
        -------
        None

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

    def GetTypeMode(self) -> "Standard_Integer":
        r"""GetTypeMode(StepData_StepWriter self) -> Standard_Integer"""
        return _StepData.StepData_StepWriter_GetTypeMode(self)

    def SetTypeMode(self, value: "Standard_Integer") -> "void":
        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"""
        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.

        Parameters
        ----------
        aprotocol: StepData_Protocol

        Returns
        -------
        None
        Creates an empty library : it will later by filled by method addprotocol.

        Returns
        -------
        None

        """
        _StepData.StepData_WriterLib_swiginit(self, _StepData.new_StepData_WriterLib(*args))

    def AddProtocol(self, *args) -> "void":
        r"""
        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).

        Parameters
        ----------
        aprotocol: Standard_Transient

        Returns
        -------
        None

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

    def Clear(self, *args) -> "void":
        r"""
        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).

        Returns
        -------
        None

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

    def Module(self, *args) -> "opencascade::handle< StepData_ReadWriteModule > const &":
        r"""
        Returns the current module in the iteration.

        Returns
        -------
        opencascade::handle<StepData_ReadWriteModule>

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

    def More(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if there are more modules to iterate on.

        Returns
        -------
        bool

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

    def Next(self, *args) -> "void":
        r"""
        Iterates by getting the next module in the list if there is none, the exception will be raised by value.

        Returns
        -------
        None

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

    def Protocol(self, *args) -> "opencascade::handle< StepData_Protocol > const &":
        r"""
        Returns the current protocol in the iteration.

        Returns
        -------
        opencascade::handle<StepData_Protocol>

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

    def Select(self, *args) -> "Standard_Boolean":
        r"""
        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).

        Parameters
        ----------
        obj: Standard_Transient
        module: StepData_ReadWriteModule

        Returns
        -------
        CN: int

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

    def SetComplete(self, *args) -> "void":
        r"""
        Sets a library to be defined with the complete global list (all the couples protocol/modules recorded in it).

        Returns
        -------
        None

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

    @staticmethod
    def SetGlobal(*args) -> "void":
        r"""
        Adds a couple (module-protocol) into the global definition set for this class of library.

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

        Returns
        -------
        None

        """
        return _StepData.StepData_WriterLib_SetGlobal(*args)

    def Start(self, *args) -> "void":
        r"""
        Starts iteration on the modules (sets it on the first one).

        Returns
        -------
        None

        """
        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)

def StepData_WriterLib_SetGlobal(*args) -> "void":
    r"""
    Adds a couple (module-protocol) into the global definition set for this class of library.

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

    Returns
    -------
    None

    """
    return _StepData.StepData_WriterLib_SetGlobal(*args)

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"""
        Creates a default general module.

        Returns
        -------
        None

        """
        _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"""
        Creates an ecdescr, empty.

        Returns
        -------
        None

        """
        _StepData.StepData_ECDescr_swiginit(self, _StepData.new_StepData_ECDescr(*args))

    def Add(self, *args) -> "void":
        r"""
        Adds a member warning : members are added in alphabetic order.

        Parameters
        ----------
        member: StepData_ESDescr

        Returns
        -------
        None

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

    def Member(self, *args) -> "opencascade::handle< StepData_ESDescr >":
        r"""
        Returns a member from its rank.

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

        Returns
        -------
        opencascade::handle<StepData_ESDescr>

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

    def NbMembers(self, *args) -> "Standard_Integer":
        r"""
        Returns the count of members.

        Returns
        -------
        int

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

    def TypeList(self, *args) -> "opencascade::handle< TColStd_HSequenceOfAsciiString >":
        r"""
        Returns the ordered list of types.

        Returns
        -------
        opencascade::handle<TColStd_HSequenceOfAsciiString>

        """
        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"""
        Creates an esdescr with a type name.

        Parameters
        ----------
        name: char *

        Returns
        -------
        None

        """
        _StepData.StepData_ESDescr_swiginit(self, _StepData.new_StepData_ESDescr(*args))

    def Base(self, *args) -> "opencascade::handle< StepData_ESDescr >":
        r"""
        Returns the basic esdescr, null if <self> is not derived.

        Returns
        -------
        opencascade::handle<StepData_ESDescr>

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

    def Field(self, *args) -> "opencascade::handle< StepData_PDescr >":
        r"""
        Returns the pdescr for the field <num> (or null).

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

        Returns
        -------
        opencascade::handle<StepData_PDescr>

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

    def IsSub(self, *args) -> "Standard_Boolean":
        r"""
        Tells if <self> is sub-type of (or equal to) another one.

        Parameters
        ----------
        other: StepData_ESDescr

        Returns
        -------
        bool

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

    def Name(self, *args) -> "char const *":
        r"""
        Returns the name of a field from its rank. empty if outofrange.

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

        Returns
        -------
        char *

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

    def NamedField(self, *args) -> "opencascade::handle< StepData_PDescr >":
        r"""
        Returns the pdescr for the field named <name> (or null).

        Parameters
        ----------
        name: char *

        Returns
        -------
        opencascade::handle<StepData_PDescr>

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

    def NbFields(self, *args) -> "Standard_Integer":
        r"""
        Returns the count of fields.

        Returns
        -------
        int

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

    def Rank(self, *args) -> "Standard_Integer":
        r"""
        Returns the rank of a field from its name. 0 if unknown.

        Parameters
        ----------
        name: char *

        Returns
        -------
        int

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

    def SetBase(self, *args) -> "void":
        r"""
        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.

        Parameters
        ----------
        base: StepData_ESDescr

        Returns
        -------
        None

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

    def SetField(self, *args) -> "void":
        r"""
        Sets a pdescr to describe a field a field is designated by its rank and name.

        Parameters
        ----------
        num: int
        name: char *
        descr: StepData_PDescr

        Returns
        -------
        None

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

    def SetNbFields(self, *args) -> "void":
        r"""
        Sets a new count of fields each one is described by a pdescr.

        Parameters
        ----------
        nb: int

        Returns
        -------
        None

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

    def SetSuper(self, *args) -> "void":
        r"""
        Sets an esdescr as 'super-type'. applies an a base (non derived) esdescr.

        Parameters
        ----------
        super: StepData_ESDescr

        Returns
        -------
        None

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

    def StepType(self, *args) -> "TCollection_AsciiString const &":
        r"""
        Returns the type name as an asciistring.

        Returns
        -------
        TCollection_AsciiString

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

    def Super(self, *args) -> "opencascade::handle< StepData_ESDescr >":
        r"""
        Returns the super-type esdescr, null if <self> is root.

        Returns
        -------
        opencascade::handle<StepData_ESDescr>

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

    def TypeName(self, *args) -> "char const *":
        r"""
        Returns the type name given at creation time.

        Returns
        -------
        char *

        """
        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"""
        Creates a fieldlist of 1 field.

        Returns
        -------
        None

        """
        _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"""
        Creates a fieldlistd of <nb> fields.

        Parameters
        ----------
        nb: int

        Returns
        -------
        None

        """
        _StepData.StepData_FieldListD_swiginit(self, _StepData.new_StepData_FieldListD(*args))

    def SetNb(self, *args) -> "void":
        r"""
        Sets a new count of fields. former contents are lost.

        Parameters
        ----------
        nb: int

        Returns
        -------
        None

        """
        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"""
        Creates a fieldlistn of <nb> fields.

        Parameters
        ----------
        nb: int

        Returns
        -------
        None

        """
        _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"""
        Creates an empty fileprotocol.

        Returns
        -------
        None

        """
        _StepData.StepData_FileProtocol_swiginit(self, _StepData.new_StepData_FileProtocol(*args))

    def Add(self, *args) -> "void":
        r"""
        Adds a protocol to the definition list of the fileprotocol but ensures that each class of protocol is present only once in this list.

        Parameters
        ----------
        protocol: StepData_Protocol

        Returns
        -------
        None

        """
        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"""
        Creates a plex (empty). the complete creation is made by the ecdescr itself, by calling add.

        Parameters
        ----------
        descr: StepData_ECDescr

        Returns
        -------
        None

        """
        _StepData.StepData_Plex_swiginit(self, _StepData.new_StepData_Plex(*args))

    def Add(self, *args) -> "void":
        r"""
        Adds a member to <self>.

        Parameters
        ----------
        member: StepData_Simple

        Returns
        -------
        None

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

    def ECDescr(self, *args) -> "opencascade::handle< StepData_ECDescr >":
        r"""
        Returns the description as for a plex.

        Returns
        -------
        opencascade::handle<StepData_ECDescr>

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

    def Member(self, *args) -> "opencascade::handle< StepData_Simple >":
        r"""
        Returns a simple member from its rank.

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

        Returns
        -------
        opencascade::handle<StepData_Simple>

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

    def NbMembers(self, *args) -> "Standard_Integer":
        r"""
        Returns the count of simple members.

        Returns
        -------
        int

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

    def TypeList(self, *args) -> "opencascade::handle< TColStd_HSequenceOfAsciiString >":
        r"""
        Returns the actual list of members types.

        Returns
        -------
        opencascade::handle<TColStd_HSequenceOfAsciiString>

        """
        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"""
        No available documentation.

        Returns
        -------
        None

        """
        _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"""
        No available documentation.

        Returns
        -------
        None

        """
        _StepData.StepData_SelectNamed_swiginit(self, _StepData.new_StepData_SelectNamed(*args))

    def CField(self, *args) -> "StepData_Field &":
        r"""
        No available documentation.

        Returns
        -------
        StepData_Field

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

    def Field(self, *args) -> "StepData_Field const &":
        r"""
        No available documentation.

        Returns
        -------
        StepData_Field

        """
        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"""
        No available documentation.

        Returns
        -------
        None

        """
        _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"""
        Creates a simple entity.

        Parameters
        ----------
        descr: StepData_ESDescr

        Returns
        -------
        None

        """
        _StepData.StepData_Simple_swiginit(self, _StepData.new_StepData_Simple(*args))

    def CFieldNum(self, *args) -> "StepData_Field &":
        r"""
        Returns a field from its rank, in order to modify it.

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

        Returns
        -------
        StepData_Field

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

    def CFields(self, *args) -> "StepData_FieldListN &":
        r"""
        Returns the entire field list, read or write.

        Returns
        -------
        StepData_FieldListN

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

    def ESDescr(self, *args) -> "opencascade::handle< StepData_ESDescr >":
        r"""
        Returns description, as for simple.

        Returns
        -------
        opencascade::handle<StepData_ESDescr>

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

    def FieldNum(self, *args) -> "StepData_Field const &":
        r"""
        Returns a field from its rank, for read-only use.

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

        Returns
        -------
        StepData_Field

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

    def Fields(self, *args) -> "StepData_FieldListN const &":
        r"""
        Returns the entire field list, read-only.

        Returns
        -------
        StepData_FieldListN

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

    def NbFields(self, *args) -> "Standard_Integer":
        r"""
        Returns the count of fields.

        Returns
        -------
        int

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

    def StepType(self, *args) -> "char const *":
        r"""
        Returns the recorded steptype (typename of its esdescr).

        Returns
        -------
        char *

        """
        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"""
        No available documentation.

        Returns
        -------
        None

        """
        _StepData.StepData_SelectArrReal_swiginit(self, _StepData.new_StepData_SelectArrReal(*args))

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

        Returns
        -------
        opencascade::handle<TColStd_HArray1OfReal>

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

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

        Parameters
        ----------
        arr: TColStd_HArray1OfReal

        Returns
        -------
        None

        """
        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) -> "StepData_Array1OfField const &":
        return _StepData.StepData_HArray1OfField_Array1(self)

    def ChangeArray1(self) -> "StepData_Array1OfField &":
        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)





