
// std lib related includes
#include <tuple>

// pybind 11 related includes
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

namespace py = pybind11;

// Standard Handle
#include <Standard_Handle.hxx>


// includes to resolve forward declarations
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepAP214_Protocol.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Approval.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_DateAndTime.hxx>
#include <StepBasic_DateTimeRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Date.hxx>
#include <StepBasic_DateRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Document.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_IdentificationRole.hxx>
#include <StepBasic_ExternalSource.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Group.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Organization.hxx>
#include <StepBasic_OrganizationRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_PersonAndOrganization.hxx>
#include <StepBasic_PersonAndOrganizationRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_SecurityClassification.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_AssemblyComponentUsageSubstitute.hxx>
#include <StepBasic_DocumentFile.hxx>
#include <StepRepr_MaterialDesignation.hxx>
#include <StepVisual_MechanicalDesignGeometricPresentationRepresentation.hxx>
#include <StepVisual_PresentationArea.hxx>
#include <StepBasic_Product.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepBasic_ProductDefinitionFormation.hxx>
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <StepRepr_PropertyDefinition.hxx>
#include <StepShape_ShapeRepresentation.hxx>
#include <StepBasic_SecurityClassification.hxx>
#include <StepRepr_ConfigurationItem.hxx>
#include <StepBasic_Date.hxx>
#include <StepBasic_Document.hxx>
#include <StepBasic_Effectivity.hxx>
#include <StepBasic_Group.hxx>
#include <StepBasic_GroupRelationship.hxx>
#include <StepBasic_ProductDefinitionFormationRelationship.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_ShapeAspectRelationship.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_DateAndTime.hxx>
#include <StepBasic_DateTimeRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Date.hxx>
#include <StepBasic_DateRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Approval.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_PersonAndOrganization.hxx>
#include <StepBasic_PersonAndOrganizationRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepAP214_AutoDesignOrganizationAssignment.hxx>
#include <StepBasic_Product.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepBasic_ProductDefinitionFormation.hxx>
#include <StepRepr_Representation.hxx>
#include <StepAP214_AutoDesignDocumentReference.hxx>
#include <StepRepr_ExternallyDefinedRepresentation.hxx>
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <StepBasic_ProductDefinitionWithAssociatedDocuments.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_ApprovalPersonOrganization.hxx>
#include <StepAP214_AutoDesignDateAndPersonAssignment.hxx>
#include <StepBasic_ProductDefinitionEffectivity.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_ApprovalPersonOrganization.hxx>
#include <StepAP214_AutoDesignDateAndPersonAssignment.hxx>
#include <StepBasic_ProductDefinitionEffectivity.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Document.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Product.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepBasic_ProductDefinitionFormation.hxx>
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <StepBasic_ProductDefinitionWithAssociatedDocuments.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_ExternallyDefinedRepresentation.hxx>
#include <StepAP214_AutoDesignDocumentReference.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Group.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepShape_AdvancedBrepShapeRepresentation.hxx>
#include <StepShape_CsgShapeRepresentation.hxx>
#include <StepShape_FacetedBrepShapeRepresentation.hxx>
#include <StepShape_GeometricallyBoundedSurfaceShapeRepresentation.hxx>
#include <StepShape_GeometricallyBoundedWireframeShapeRepresentation.hxx>
#include <StepShape_ManifoldSurfaceShapeRepresentation.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepShape_ShapeRepresentation.hxx>
#include <StepVisual_TemplateInstance.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_DateAndTime.hxx>
#include <StepBasic_DateTimeRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Date.hxx>
#include <StepBasic_DateRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Organization.hxx>
#include <StepBasic_OrganizationRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Document.hxx>
#include <StepBasic_PhysicallyModeledProductDefinition.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_PersonAndOrganization.hxx>
#include <StepBasic_PersonAndOrganizationRole.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepRepr_ProductDefinitionShape.hxx>
#include <StepRepr_RepresentationRelationship.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepBasic_DocumentRelationship.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Approval.hxx>
#include <StepBasic_DocumentRelationship.hxx>
#include <StepRepr_ExternallyDefinedRepresentation.hxx>
#include <StepRepr_MappedItem.hxx>
#include <StepRepr_MaterialDesignation.hxx>
#include <StepVisual_PresentationArea.hxx>
#include <StepVisual_PresentationView.hxx>
#include <StepBasic_ProductCategory.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <StepRepr_PropertyDefinition.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_RepresentationRelationship.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_SecurityClassification.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_ApprovalPersonOrganization.hxx>
#include <StepAP214_AppliedPersonAndOrganizationAssignment.hxx>
#include <StepAP214_AppliedOrganizationAssignment.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_ApprovalPersonOrganization.hxx>
#include <StepAP214_AppliedPersonAndOrganizationAssignment.hxx>
#include <StepAP214_AppliedOrganizationAssignment.hxx>
#include <StepAP214_AppliedSecurityClassificationAssignment.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Approval.hxx>
#include <StepRepr_DescriptiveRepresentationItem.hxx>
#include <StepRepr_MaterialDesignation.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <StepRepr_PropertyDefinition.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepRepr_ShapeAspectRelationship.hxx>
#include <StepAP214_AppliedExternalIdentificationAssignment.hxx>
#include <StepRepr_AssemblyComponentUsage.hxx>
#include <StepBasic_CharacterizedObject.hxx>
#include <StepShape_DimensionalSize.hxx>
#include <StepBasic_ExternallyDefinedItem.hxx>
#include <StepBasic_Group.hxx>
#include <StepBasic_GroupRelationship.hxx>
#include <StepBasic_ProductCategory.hxx>
#include <StepRepr_MeasureRepresentationItem.hxx>
#include <StepBasic_ProductDefinitionContext.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_DocumentFile.hxx>
#include <StepAP214_AppliedOrganizationAssignment.hxx>
#include <StepAP214_AppliedPersonAndOrganizationAssignment.hxx>
#include <StepAP214_ExternallyDefinedClass.hxx>
#include <StepAP214_ExternallyDefinedGeneralProperty.hxx>
#include <StepBasic_Approval.hxx>
#include <StepBasic_ApprovalStatus.hxx>
#include <StepBasic_ExternalSource.hxx>
#include <StepBasic_OrganizationalAddress.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepBasic_SecurityClassification.hxx>
#include <StepBasic_VersionedActionRequest.hxx>
#include <StepGeom_TrimmedCurve.hxx>
#include <StepBasic_DateAndTimeAssignment.hxx>
#include <StepBasic_DateAssignment.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_ExternallyDefinedItem.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_SourceItem.hxx>
#include <StepBasic_ExternalSource.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_ExternallyDefinedItem.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_SourceItem.hxx>
#include <StepBasic_ExternalSource.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepGeom_GeometricRepresentationItem.hxx>
#include <StepBasic_GroupRelationship.hxx>
#include <StepRepr_MappedItem.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepBasic_ProductDefinitionFormation.hxx>
#include <StepRepr_PropertyDefinitionRepresentation.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <StepRepr_RepresentationRelationshipWithTransformation.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepRepr_ShapeAspectRelationship.hxx>
#include <StepRepr_ShapeRepresentationRelationship.hxx>
#include <StepVisual_StyledItem.hxx>
#include <StepShape_TopologicalRepresentationItem.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepAP214_AppliedOrganizationAssignment.hxx>
#include <StepBasic_Approval.hxx>
#include <StepAP214_AppliedSecurityClassificationAssignment.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepAP214_AppliedOrganizationAssignment.hxx>
#include <StepAP214_AppliedSecurityClassificationAssignment.hxx>
#include <StepBasic_Approval.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_Action.hxx>
#include <StepRepr_AssemblyComponentUsage.hxx>
#include <StepRepr_ConfigurationDesign.hxx>
#include <StepRepr_ConfigurationEffectivity.hxx>
#include <StepVisual_DraughtingModel.hxx>
#include <StepBasic_GeneralProperty.hxx>
#include <StepRepr_MakeFromUsageOption.hxx>
#include <StepRepr_ProductConcept.hxx>
#include <StepRepr_ProductDefinitionUsage.hxx>
#include <StepBasic_VersionedActionRequest.hxx>

// module includes
#include <StepAP214.hxx>
#include <StepAP214_AppliedApprovalAssignment.hxx>
#include <StepAP214_AppliedDateAndTimeAssignment.hxx>
#include <StepAP214_AppliedDateAssignment.hxx>
#include <StepAP214_AppliedDocumentReference.hxx>
#include <StepAP214_AppliedExternalIdentificationAssignment.hxx>
#include <StepAP214_AppliedGroupAssignment.hxx>
#include <StepAP214_AppliedOrganizationAssignment.hxx>
#include <StepAP214_AppliedPersonAndOrganizationAssignment.hxx>
#include <StepAP214_AppliedPresentedItem.hxx>
#include <StepAP214_AppliedSecurityClassificationAssignment.hxx>
#include <StepAP214_ApprovalItem.hxx>
#include <StepAP214_Array1OfApprovalItem.hxx>
#include <StepAP214_Array1OfAutoDesignDateAndPersonItem.hxx>
#include <StepAP214_Array1OfAutoDesignDateAndTimeItem.hxx>
#include <StepAP214_Array1OfAutoDesignDatedItem.hxx>
#include <StepAP214_Array1OfAutoDesignGeneralOrgItem.hxx>
#include <StepAP214_Array1OfAutoDesignGroupedItem.hxx>
#include <StepAP214_Array1OfAutoDesignPresentedItemSelect.hxx>
#include <StepAP214_Array1OfAutoDesignReferencingItem.hxx>
#include <StepAP214_Array1OfDateAndTimeItem.hxx>
#include <StepAP214_Array1OfDateItem.hxx>
#include <StepAP214_Array1OfDocumentReferenceItem.hxx>
#include <StepAP214_Array1OfExternalIdentificationItem.hxx>
#include <StepAP214_Array1OfGroupItem.hxx>
#include <StepAP214_Array1OfOrganizationItem.hxx>
#include <StepAP214_Array1OfPersonAndOrganizationItem.hxx>
#include <StepAP214_Array1OfPresentedItemSelect.hxx>
#include <StepAP214_Array1OfSecurityClassificationItem.hxx>
#include <StepAP214_AutoDesignActualDateAndTimeAssignment.hxx>
#include <StepAP214_AutoDesignActualDateAssignment.hxx>
#include <StepAP214_AutoDesignApprovalAssignment.hxx>
#include <StepAP214_AutoDesignDateAndPersonAssignment.hxx>
#include <StepAP214_AutoDesignDateAndPersonItem.hxx>
#include <StepAP214_AutoDesignDateAndTimeItem.hxx>
#include <StepAP214_AutoDesignDatedItem.hxx>
#include <StepAP214_AutoDesignDocumentReference.hxx>
#include <StepAP214_AutoDesignGeneralOrgItem.hxx>
#include <StepAP214_AutoDesignGroupAssignment.hxx>
#include <StepAP214_AutoDesignGroupedItem.hxx>
#include <StepAP214_AutoDesignNominalDateAndTimeAssignment.hxx>
#include <StepAP214_AutoDesignNominalDateAssignment.hxx>
#include <StepAP214_AutoDesignOrganizationAssignment.hxx>
#include <StepAP214_AutoDesignOrganizationItem.hxx>
#include <StepAP214_AutoDesignPersonAndOrganizationAssignment.hxx>
#include <StepAP214_AutoDesignPresentedItem.hxx>
#include <StepAP214_AutoDesignPresentedItemSelect.hxx>
#include <StepAP214_AutoDesignReferencingItem.hxx>
#include <StepAP214_AutoDesignSecurityClassificationAssignment.hxx>
#include <StepAP214_Class.hxx>
#include <StepAP214_DateAndTimeItem.hxx>
#include <StepAP214_DateItem.hxx>
#include <StepAP214_DocumentReferenceItem.hxx>
#include <StepAP214_ExternalIdentificationItem.hxx>
#include <StepAP214_ExternallyDefinedClass.hxx>
#include <StepAP214_ExternallyDefinedGeneralProperty.hxx>
#include <StepAP214_GroupItem.hxx>
#include <StepAP214_HArray1OfApprovalItem.hxx>
#include <StepAP214_HArray1OfAutoDesignDateAndPersonItem.hxx>
#include <StepAP214_HArray1OfAutoDesignDateAndTimeItem.hxx>
#include <StepAP214_HArray1OfAutoDesignDatedItem.hxx>
#include <StepAP214_HArray1OfAutoDesignGeneralOrgItem.hxx>
#include <StepAP214_HArray1OfAutoDesignGroupedItem.hxx>
#include <StepAP214_HArray1OfAutoDesignPresentedItemSelect.hxx>
#include <StepAP214_HArray1OfAutoDesignReferencingItem.hxx>
#include <StepAP214_HArray1OfDateAndTimeItem.hxx>
#include <StepAP214_HArray1OfDateItem.hxx>
#include <StepAP214_HArray1OfDocumentReferenceItem.hxx>
#include <StepAP214_HArray1OfExternalIdentificationItem.hxx>
#include <StepAP214_HArray1OfGroupItem.hxx>
#include <StepAP214_HArray1OfOrganizationItem.hxx>
#include <StepAP214_HArray1OfPersonAndOrganizationItem.hxx>
#include <StepAP214_HArray1OfPresentedItemSelect.hxx>
#include <StepAP214_HArray1OfSecurityClassificationItem.hxx>
#include <StepAP214_OrganizationItem.hxx>
#include <StepAP214_PersonAndOrganizationItem.hxx>
#include <StepAP214_PresentedItemSelect.hxx>
#include <StepAP214_Protocol.hxx>
#include <StepAP214_RepItemGroup.hxx>
#include <StepAP214_SecurityClassificationItem.hxx>

// template related includes

// ./opencascade/StepAP214_Array1OfApprovalItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfAutoDesignDateAndPersonItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfAutoDesignDateAndTimeItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfAutoDesignDatedItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfAutoDesignGeneralOrgItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfAutoDesignGroupedItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfAutoDesignPresentedItemSelect.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfAutoDesignReferencingItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfDateAndTimeItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfDateItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfDocumentReferenceItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfExternalIdentificationItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfGroupItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfOrganizationItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfPersonAndOrganizationItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfPresentedItemSelect.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepAP214_Array1OfSecurityClassificationItem.hxx
#include "NCollection_tmpl.hxx"


// user-defined pre
#include "OCP_specific.inc"

// user-defined inclusion per module
#include <Interface_InterfaceModel.hxx>

// Module definiiton
void register_StepAP214(py::module &main_module) {


py::module m = static_cast<py::module>(main_module.attr("StepAP214"));
py::object klass;

//Python trampoline classes

// classes

    // Class StepAP214 from ./opencascade/StepAP214.hxx
    klass = m.attr("StepAP214");

    // default constructor
    register_default_constructor<StepAP214 , shared_ptr<StepAP214>>(m,"StepAP214");

    // nested enums

    static_cast<py::class_<StepAP214 , shared_ptr<StepAP214>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("Protocol_s",
                    (handle<StepAP214_Protocol> (*)() ) static_cast<handle<StepAP214_Protocol> (*)() >(&StepAP214::Protocol),
                    R"#(creates a Protocol)#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_AppliedApprovalAssignment from ./opencascade/StepAP214_AppliedApprovalAssignment.hxx
    klass = m.attr("StepAP214_AppliedApprovalAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedApprovalAssignment ,opencascade::handle<StepAP214_AppliedApprovalAssignment>  , StepBasic_ApprovalAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedApprovalAssignment::*)(  const handle<StepBasic_Approval> & ,   const handle<StepAP214_HArray1OfApprovalItem> &  ) ) static_cast<void (StepAP214_AppliedApprovalAssignment::*)(  const handle<StepBasic_Approval> & ,   const handle<StepAP214_HArray1OfApprovalItem> &  ) >(&StepAP214_AppliedApprovalAssignment::Init),
             R"#()#"  , py::arg("aAssignedApproval"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AppliedApprovalAssignment::*)(  const handle<StepAP214_HArray1OfApprovalItem> &  ) ) static_cast<void (StepAP214_AppliedApprovalAssignment::*)(  const handle<StepAP214_HArray1OfApprovalItem> &  ) >(&StepAP214_AppliedApprovalAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfApprovalItem> (StepAP214_AppliedApprovalAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfApprovalItem> (StepAP214_AppliedApprovalAssignment::*)() const>(&StepAP214_AppliedApprovalAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_ApprovalItem (StepAP214_AppliedApprovalAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_ApprovalItem (StepAP214_AppliedApprovalAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AppliedApprovalAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AppliedApprovalAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AppliedApprovalAssignment::*)() const>(&StepAP214_AppliedApprovalAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedApprovalAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedApprovalAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedApprovalAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedApprovalAssignment::*)() const>(&StepAP214_AppliedApprovalAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AppliedDateAndTimeAssignment from ./opencascade/StepAP214_AppliedDateAndTimeAssignment.hxx
    klass = m.attr("StepAP214_AppliedDateAndTimeAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedDateAndTimeAssignment ,opencascade::handle<StepAP214_AppliedDateAndTimeAssignment>  , StepBasic_DateAndTimeAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedDateAndTimeAssignment::*)(  const handle<StepBasic_DateAndTime> & ,   const handle<StepBasic_DateTimeRole> & ,   const handle<StepAP214_HArray1OfDateAndTimeItem> &  ) ) static_cast<void (StepAP214_AppliedDateAndTimeAssignment::*)(  const handle<StepBasic_DateAndTime> & ,   const handle<StepBasic_DateTimeRole> & ,   const handle<StepAP214_HArray1OfDateAndTimeItem> &  ) >(&StepAP214_AppliedDateAndTimeAssignment::Init),
             R"#()#"  , py::arg("aAssignedDateAndTime"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AppliedDateAndTimeAssignment::*)(  const handle<StepAP214_HArray1OfDateAndTimeItem> &  ) ) static_cast<void (StepAP214_AppliedDateAndTimeAssignment::*)(  const handle<StepAP214_HArray1OfDateAndTimeItem> &  ) >(&StepAP214_AppliedDateAndTimeAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfDateAndTimeItem> (StepAP214_AppliedDateAndTimeAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfDateAndTimeItem> (StepAP214_AppliedDateAndTimeAssignment::*)() const>(&StepAP214_AppliedDateAndTimeAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_DateAndTimeItem (StepAP214_AppliedDateAndTimeAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_DateAndTimeItem (StepAP214_AppliedDateAndTimeAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AppliedDateAndTimeAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AppliedDateAndTimeAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AppliedDateAndTimeAssignment::*)() const>(&StepAP214_AppliedDateAndTimeAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedDateAndTimeAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedDateAndTimeAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedDateAndTimeAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedDateAndTimeAssignment::*)() const>(&StepAP214_AppliedDateAndTimeAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AppliedDateAssignment from ./opencascade/StepAP214_AppliedDateAssignment.hxx
    klass = m.attr("StepAP214_AppliedDateAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedDateAssignment ,opencascade::handle<StepAP214_AppliedDateAssignment>  , StepBasic_DateAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedDateAssignment::*)(  const handle<StepBasic_Date> & ,   const handle<StepBasic_DateRole> & ,   const handle<StepAP214_HArray1OfDateItem> &  ) ) static_cast<void (StepAP214_AppliedDateAssignment::*)(  const handle<StepBasic_Date> & ,   const handle<StepBasic_DateRole> & ,   const handle<StepAP214_HArray1OfDateItem> &  ) >(&StepAP214_AppliedDateAssignment::Init),
             R"#()#"  , py::arg("aAssignedDate"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AppliedDateAssignment::*)(  const handle<StepAP214_HArray1OfDateItem> &  ) ) static_cast<void (StepAP214_AppliedDateAssignment::*)(  const handle<StepAP214_HArray1OfDateItem> &  ) >(&StepAP214_AppliedDateAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfDateItem> (StepAP214_AppliedDateAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfDateItem> (StepAP214_AppliedDateAssignment::*)() const>(&StepAP214_AppliedDateAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_DateItem (StepAP214_AppliedDateAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_DateItem (StepAP214_AppliedDateAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AppliedDateAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AppliedDateAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AppliedDateAssignment::*)() const>(&StepAP214_AppliedDateAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedDateAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedDateAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedDateAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedDateAssignment::*)() const>(&StepAP214_AppliedDateAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AppliedDocumentReference from ./opencascade/StepAP214_AppliedDocumentReference.hxx
    klass = m.attr("StepAP214_AppliedDocumentReference");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedDocumentReference ,opencascade::handle<StepAP214_AppliedDocumentReference>  , StepBasic_DocumentReference >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedDocumentReference::*)(  const handle<StepBasic_Document> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepAP214_HArray1OfDocumentReferenceItem> &  ) ) static_cast<void (StepAP214_AppliedDocumentReference::*)(  const handle<StepBasic_Document> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepAP214_HArray1OfDocumentReferenceItem> &  ) >(&StepAP214_AppliedDocumentReference::Init),
             R"#()#"  , py::arg("aAssignedDocument"),  py::arg("aSource"),  py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfDocumentReferenceItem> (StepAP214_AppliedDocumentReference::*)() const) static_cast<handle<StepAP214_HArray1OfDocumentReferenceItem> (StepAP214_AppliedDocumentReference::*)() const>(&StepAP214_AppliedDocumentReference::Items),
             R"#()#" 
          )
        .def("SetItems",
             (void (StepAP214_AppliedDocumentReference::*)(  const handle<StepAP214_HArray1OfDocumentReferenceItem> &  ) ) static_cast<void (StepAP214_AppliedDocumentReference::*)(  const handle<StepAP214_HArray1OfDocumentReferenceItem> &  ) >(&StepAP214_AppliedDocumentReference::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("ItemsValue",
             (StepAP214_DocumentReferenceItem (StepAP214_AppliedDocumentReference::*)(  const Standard_Integer  ) const) static_cast<StepAP214_DocumentReferenceItem (StepAP214_AppliedDocumentReference::*)(  const Standard_Integer  ) const>(&StepAP214_AppliedDocumentReference::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AppliedDocumentReference::*)() const) static_cast<Standard_Integer (StepAP214_AppliedDocumentReference::*)() const>(&StepAP214_AppliedDocumentReference::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedDocumentReference::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedDocumentReference::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedDocumentReference::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedDocumentReference::*)() const>(&StepAP214_AppliedDocumentReference::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AppliedExternalIdentificationAssignment from ./opencascade/StepAP214_AppliedExternalIdentificationAssignment.hxx
    klass = m.attr("StepAP214_AppliedExternalIdentificationAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedExternalIdentificationAssignment ,opencascade::handle<StepAP214_AppliedExternalIdentificationAssignment>  , StepBasic_ExternalIdentificationAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedExternalIdentificationAssignment::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_IdentificationRole> & ,   const handle<StepBasic_ExternalSource> & ,   const handle<StepAP214_HArray1OfExternalIdentificationItem> &  ) ) static_cast<void (StepAP214_AppliedExternalIdentificationAssignment::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_IdentificationRole> & ,   const handle<StepBasic_ExternalSource> & ,   const handle<StepAP214_HArray1OfExternalIdentificationItem> &  ) >(&StepAP214_AppliedExternalIdentificationAssignment::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aIdentificationAssignment_AssignedId"),  py::arg("aIdentificationAssignment_Role"),  py::arg("aExternalIdentificationAssignment_Source"),  py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfExternalIdentificationItem> (StepAP214_AppliedExternalIdentificationAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfExternalIdentificationItem> (StepAP214_AppliedExternalIdentificationAssignment::*)() const>(&StepAP214_AppliedExternalIdentificationAssignment::Items),
             R"#(Returns field Items)#" 
          )
        .def("SetItems",
             (void (StepAP214_AppliedExternalIdentificationAssignment::*)(  const handle<StepAP214_HArray1OfExternalIdentificationItem> &  ) ) static_cast<void (StepAP214_AppliedExternalIdentificationAssignment::*)(  const handle<StepAP214_HArray1OfExternalIdentificationItem> &  ) >(&StepAP214_AppliedExternalIdentificationAssignment::SetItems),
             R"#(Set field Items)#"  , py::arg("Items")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedExternalIdentificationAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedExternalIdentificationAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedExternalIdentificationAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedExternalIdentificationAssignment::*)() const>(&StepAP214_AppliedExternalIdentificationAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AppliedGroupAssignment from ./opencascade/StepAP214_AppliedGroupAssignment.hxx
    klass = m.attr("StepAP214_AppliedGroupAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedGroupAssignment ,opencascade::handle<StepAP214_AppliedGroupAssignment>  , StepBasic_GroupAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedGroupAssignment::*)(  const handle<StepBasic_Group> & ,   const handle<StepAP214_HArray1OfGroupItem> &  ) ) static_cast<void (StepAP214_AppliedGroupAssignment::*)(  const handle<StepBasic_Group> & ,   const handle<StepAP214_HArray1OfGroupItem> &  ) >(&StepAP214_AppliedGroupAssignment::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aGroupAssignment_AssignedGroup"),  py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfGroupItem> (StepAP214_AppliedGroupAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfGroupItem> (StepAP214_AppliedGroupAssignment::*)() const>(&StepAP214_AppliedGroupAssignment::Items),
             R"#(Returns field Items)#" 
          )
        .def("SetItems",
             (void (StepAP214_AppliedGroupAssignment::*)(  const handle<StepAP214_HArray1OfGroupItem> &  ) ) static_cast<void (StepAP214_AppliedGroupAssignment::*)(  const handle<StepAP214_HArray1OfGroupItem> &  ) >(&StepAP214_AppliedGroupAssignment::SetItems),
             R"#(Set field Items)#"  , py::arg("Items")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedGroupAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedGroupAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedGroupAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedGroupAssignment::*)() const>(&StepAP214_AppliedGroupAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AppliedOrganizationAssignment from ./opencascade/StepAP214_AppliedOrganizationAssignment.hxx
    klass = m.attr("StepAP214_AppliedOrganizationAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedOrganizationAssignment ,opencascade::handle<StepAP214_AppliedOrganizationAssignment>  , StepBasic_OrganizationAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedOrganizationAssignment::*)(  const handle<StepBasic_Organization> & ,   const handle<StepBasic_OrganizationRole> & ,   const handle<StepAP214_HArray1OfOrganizationItem> &  ) ) static_cast<void (StepAP214_AppliedOrganizationAssignment::*)(  const handle<StepBasic_Organization> & ,   const handle<StepBasic_OrganizationRole> & ,   const handle<StepAP214_HArray1OfOrganizationItem> &  ) >(&StepAP214_AppliedOrganizationAssignment::Init),
             R"#()#"  , py::arg("aAssignedOrganization"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AppliedOrganizationAssignment::*)(  const handle<StepAP214_HArray1OfOrganizationItem> &  ) ) static_cast<void (StepAP214_AppliedOrganizationAssignment::*)(  const handle<StepAP214_HArray1OfOrganizationItem> &  ) >(&StepAP214_AppliedOrganizationAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfOrganizationItem> (StepAP214_AppliedOrganizationAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfOrganizationItem> (StepAP214_AppliedOrganizationAssignment::*)() const>(&StepAP214_AppliedOrganizationAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_OrganizationItem (StepAP214_AppliedOrganizationAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_OrganizationItem (StepAP214_AppliedOrganizationAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AppliedOrganizationAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AppliedOrganizationAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AppliedOrganizationAssignment::*)() const>(&StepAP214_AppliedOrganizationAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedOrganizationAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedOrganizationAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedOrganizationAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedOrganizationAssignment::*)() const>(&StepAP214_AppliedOrganizationAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AppliedPersonAndOrganizationAssignment from ./opencascade/StepAP214_AppliedPersonAndOrganizationAssignment.hxx
    klass = m.attr("StepAP214_AppliedPersonAndOrganizationAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedPersonAndOrganizationAssignment ,opencascade::handle<StepAP214_AppliedPersonAndOrganizationAssignment>  , StepBasic_PersonAndOrganizationAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedPersonAndOrganizationAssignment::*)(  const handle<StepBasic_PersonAndOrganization> & ,   const handle<StepBasic_PersonAndOrganizationRole> & ,   const handle<StepAP214_HArray1OfPersonAndOrganizationItem> &  ) ) static_cast<void (StepAP214_AppliedPersonAndOrganizationAssignment::*)(  const handle<StepBasic_PersonAndOrganization> & ,   const handle<StepBasic_PersonAndOrganizationRole> & ,   const handle<StepAP214_HArray1OfPersonAndOrganizationItem> &  ) >(&StepAP214_AppliedPersonAndOrganizationAssignment::Init),
             R"#()#"  , py::arg("aAssignedPersonAndOrganization"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AppliedPersonAndOrganizationAssignment::*)(  const handle<StepAP214_HArray1OfPersonAndOrganizationItem> &  ) ) static_cast<void (StepAP214_AppliedPersonAndOrganizationAssignment::*)(  const handle<StepAP214_HArray1OfPersonAndOrganizationItem> &  ) >(&StepAP214_AppliedPersonAndOrganizationAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfPersonAndOrganizationItem> (StepAP214_AppliedPersonAndOrganizationAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfPersonAndOrganizationItem> (StepAP214_AppliedPersonAndOrganizationAssignment::*)() const>(&StepAP214_AppliedPersonAndOrganizationAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_PersonAndOrganizationItem (StepAP214_AppliedPersonAndOrganizationAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_PersonAndOrganizationItem (StepAP214_AppliedPersonAndOrganizationAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AppliedPersonAndOrganizationAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AppliedPersonAndOrganizationAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AppliedPersonAndOrganizationAssignment::*)() const>(&StepAP214_AppliedPersonAndOrganizationAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedPersonAndOrganizationAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedPersonAndOrganizationAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedPersonAndOrganizationAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedPersonAndOrganizationAssignment::*)() const>(&StepAP214_AppliedPersonAndOrganizationAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AppliedPresentedItem from ./opencascade/StepAP214_AppliedPresentedItem.hxx
    klass = m.attr("StepAP214_AppliedPresentedItem");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedPresentedItem ,opencascade::handle<StepAP214_AppliedPresentedItem>  , StepVisual_PresentedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedPresentedItem::*)(  const handle<StepAP214_HArray1OfPresentedItemSelect> &  ) ) static_cast<void (StepAP214_AppliedPresentedItem::*)(  const handle<StepAP214_HArray1OfPresentedItemSelect> &  ) >(&StepAP214_AppliedPresentedItem::Init),
             R"#()#"  , py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AppliedPresentedItem::*)(  const handle<StepAP214_HArray1OfPresentedItemSelect> &  ) ) static_cast<void (StepAP214_AppliedPresentedItem::*)(  const handle<StepAP214_HArray1OfPresentedItemSelect> &  ) >(&StepAP214_AppliedPresentedItem::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfPresentedItemSelect> (StepAP214_AppliedPresentedItem::*)() const) static_cast<handle<StepAP214_HArray1OfPresentedItemSelect> (StepAP214_AppliedPresentedItem::*)() const>(&StepAP214_AppliedPresentedItem::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_PresentedItemSelect (StepAP214_AppliedPresentedItem::*)(  const Standard_Integer  ) const) static_cast<StepAP214_PresentedItemSelect (StepAP214_AppliedPresentedItem::*)(  const Standard_Integer  ) const>(&StepAP214_AppliedPresentedItem::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AppliedPresentedItem::*)() const) static_cast<Standard_Integer (StepAP214_AppliedPresentedItem::*)() const>(&StepAP214_AppliedPresentedItem::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedPresentedItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedPresentedItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedPresentedItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedPresentedItem::*)() const>(&StepAP214_AppliedPresentedItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AppliedSecurityClassificationAssignment from ./opencascade/StepAP214_AppliedSecurityClassificationAssignment.hxx
    klass = m.attr("StepAP214_AppliedSecurityClassificationAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AppliedSecurityClassificationAssignment ,opencascade::handle<StepAP214_AppliedSecurityClassificationAssignment>  , StepBasic_SecurityClassificationAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AppliedSecurityClassificationAssignment::*)(  const handle<StepBasic_SecurityClassification> & ,   const handle<StepAP214_HArray1OfSecurityClassificationItem> &  ) ) static_cast<void (StepAP214_AppliedSecurityClassificationAssignment::*)(  const handle<StepBasic_SecurityClassification> & ,   const handle<StepAP214_HArray1OfSecurityClassificationItem> &  ) >(&StepAP214_AppliedSecurityClassificationAssignment::Init),
             R"#()#"  , py::arg("aAssignedSecurityClassification"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AppliedSecurityClassificationAssignment::*)(  const handle<StepAP214_HArray1OfSecurityClassificationItem> &  ) ) static_cast<void (StepAP214_AppliedSecurityClassificationAssignment::*)(  const handle<StepAP214_HArray1OfSecurityClassificationItem> &  ) >(&StepAP214_AppliedSecurityClassificationAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfSecurityClassificationItem> (StepAP214_AppliedSecurityClassificationAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfSecurityClassificationItem> (StepAP214_AppliedSecurityClassificationAssignment::*)() const>(&StepAP214_AppliedSecurityClassificationAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             ( const StepAP214_SecurityClassificationItem & (StepAP214_AppliedSecurityClassificationAssignment::*)(  const Standard_Integer  ) const) static_cast< const StepAP214_SecurityClassificationItem & (StepAP214_AppliedSecurityClassificationAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AppliedSecurityClassificationAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AppliedSecurityClassificationAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AppliedSecurityClassificationAssignment::*)() const>(&StepAP214_AppliedSecurityClassificationAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AppliedSecurityClassificationAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AppliedSecurityClassificationAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AppliedSecurityClassificationAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AppliedSecurityClassificationAssignment::*)() const>(&StepAP214_AppliedSecurityClassificationAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_ApprovalItem from ./opencascade/StepAP214_ApprovalItem.hxx
    klass = m.attr("StepAP214_ApprovalItem");


    // nested enums

    static_cast<py::class_<StepAP214_ApprovalItem , shared_ptr<StepAP214_ApprovalItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_ApprovalItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_ApprovalItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_ApprovalItem::CaseNum),
             R"#(Recognizes a ApprovalItem Kind Entity that is : 1 -> AssemblyComponentUsageSubstitute 2 -> DocumentFile 3 -> MaterialDesignation 4 -> MechanicalDesignGeometricPresentationRepresentation 5 -> PresentationArea 6 -> Product 7 -> ProductDefinition 8 -> ProductDefinitionFormation 9 -> ProductDefinitionRelationship 10 -> PropertyDefinition 11 -> ShapeRepresentation 12 -> SecurityClassification 13 -> ConfigurationItem 14 -> Date 15 -> Document 16 -> Effectivity 17 -> Group 18 -> GroupRelationship 19 -> ProductDefinitionFormationRelationship 20 -> Representation 21 -> ShapeAspectRelationship 0 else)#"  , py::arg("ent")
          )
        .def("AssemblyComponentUsageSubstitute",
             (handle<StepRepr_AssemblyComponentUsageSubstitute> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepRepr_AssemblyComponentUsageSubstitute> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::AssemblyComponentUsageSubstitute),
             R"#(returns Value as a AssemblyComponentUsageSubstitute (Null if another type))#" 
          )
        .def("DocumentFile",
             (handle<StepBasic_DocumentFile> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_DocumentFile> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::DocumentFile),
             R"#(returns Value as a DocumentFile (Null if another type))#" 
          )
        .def("MaterialDesignation",
             (handle<StepRepr_MaterialDesignation> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepRepr_MaterialDesignation> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::MaterialDesignation),
             R"#(returns Value as a MaterialDesignation (Null if another type))#" 
          )
        .def("MechanicalDesignGeometricPresentationRepresentation",
             (handle<StepVisual_MechanicalDesignGeometricPresentationRepresentation> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepVisual_MechanicalDesignGeometricPresentationRepresentation> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::MechanicalDesignGeometricPresentationRepresentation),
             R"#(returns Value as a MechanicalDesignGeometricPresentationRepresentation (Null if another type))#" 
          )
        .def("PresentationArea",
             (handle<StepVisual_PresentationArea> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepVisual_PresentationArea> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::PresentationArea),
             R"#(returns Value as a PresentationArea (Null if another type))#" 
          )
        .def("Product",
             (handle<StepBasic_Product> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_Product> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::Product),
             R"#(returns Value as a Product (Null if another type))#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::ProductDefinition),
             R"#(returns Value as a ProductDefinition (Null if another type))#" 
          )
        .def("ProductDefinitionFormation",
             (handle<StepBasic_ProductDefinitionFormation> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionFormation> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::ProductDefinitionFormation),
             R"#(returns Value as a ProductDefinitionFormation (Null if another type))#" 
          )
        .def("ProductDefinitionRelationship",
             (handle<StepBasic_ProductDefinitionRelationship> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionRelationship> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::ProductDefinitionRelationship),
             R"#(returns Value as aProductDefinitionRelationship (Null if another type))#" 
          )
        .def("PropertyDefinition",
             (handle<StepRepr_PropertyDefinition> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepRepr_PropertyDefinition> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::PropertyDefinition),
             R"#(returns Value as a PropertyDefinition (Null if another type))#" 
          )
        .def("ShapeRepresentation",
             (handle<StepShape_ShapeRepresentation> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepShape_ShapeRepresentation> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::ShapeRepresentation),
             R"#(returns Value as a ShapeRepresentation (Null if another type))#" 
          )
        .def("SecurityClassification",
             (handle<StepBasic_SecurityClassification> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_SecurityClassification> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::SecurityClassification),
             R"#(returns Value as a SecurityClassification (Null if another type))#" 
          )
        .def("ConfigurationItem",
             (handle<StepRepr_ConfigurationItem> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepRepr_ConfigurationItem> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::ConfigurationItem),
             R"#(returns Value as a ConfigurationItem (Null if another type))#" 
          )
        .def("Date",
             (handle<StepBasic_Date> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_Date> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::Date),
             R"#(returns Value as a Date (Null if another type))#" 
          )
        .def("Document",
             (handle<StepBasic_Document> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_Document> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::Document),
             R"#(returns Value as a Document (Null if another type))#" 
          )
        .def("Effectivity",
             (handle<StepBasic_Effectivity> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_Effectivity> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::Effectivity),
             R"#(returns Value as a Effectivity (Null if another type))#" 
          )
        .def("Group",
             (handle<StepBasic_Group> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_Group> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::Group),
             R"#(returns Value as a Group (Null if another type))#" 
          )
        .def("GroupRelationship",
             (handle<StepBasic_GroupRelationship> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_GroupRelationship> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::GroupRelationship),
             R"#(returns Value as a GroupRelationship (Null if another type))#" 
          )
        .def("ProductDefinitionFormationRelationship",
             (handle<StepBasic_ProductDefinitionFormationRelationship> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionFormationRelationship> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::ProductDefinitionFormationRelationship),
             R"#(returns Value as a ProductDefinitionFormationRelationship (Null if another type))#" 
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepRepr_Representation> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::Representation),
             R"#(returns Value as a Representation (Null if another type))#" 
          )
        .def("ShapeAspectRelationship",
             (handle<StepRepr_ShapeAspectRelationship> (StepAP214_ApprovalItem::*)() const) static_cast<handle<StepRepr_ShapeAspectRelationship> (StepAP214_ApprovalItem::*)() const>(&StepAP214_ApprovalItem::ShapeAspectRelationship),
             R"#(returns Value as a ShapeAspectRelationship (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_AutoDesignActualDateAndTimeAssignment from ./opencascade/StepAP214_AutoDesignActualDateAndTimeAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignActualDateAndTimeAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignActualDateAndTimeAssignment ,opencascade::handle<StepAP214_AutoDesignActualDateAndTimeAssignment>  , StepBasic_DateAndTimeAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignActualDateAndTimeAssignment::*)(  const handle<StepBasic_DateAndTime> & ,   const handle<StepBasic_DateTimeRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> &  ) ) static_cast<void (StepAP214_AutoDesignActualDateAndTimeAssignment::*)(  const handle<StepBasic_DateAndTime> & ,   const handle<StepBasic_DateTimeRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> &  ) >(&StepAP214_AutoDesignActualDateAndTimeAssignment::Init),
             R"#()#"  , py::arg("aAssignedDateAndTime"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignActualDateAndTimeAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> &  ) ) static_cast<void (StepAP214_AutoDesignActualDateAndTimeAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> &  ) >(&StepAP214_AutoDesignActualDateAndTimeAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> (StepAP214_AutoDesignActualDateAndTimeAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> (StepAP214_AutoDesignActualDateAndTimeAssignment::*)() const>(&StepAP214_AutoDesignActualDateAndTimeAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignDateAndTimeItem (StepAP214_AutoDesignActualDateAndTimeAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignDateAndTimeItem (StepAP214_AutoDesignActualDateAndTimeAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignActualDateAndTimeAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignActualDateAndTimeAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignActualDateAndTimeAssignment::*)() const>(&StepAP214_AutoDesignActualDateAndTimeAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignActualDateAndTimeAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignActualDateAndTimeAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignActualDateAndTimeAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignActualDateAndTimeAssignment::*)() const>(&StepAP214_AutoDesignActualDateAndTimeAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignActualDateAssignment from ./opencascade/StepAP214_AutoDesignActualDateAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignActualDateAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignActualDateAssignment ,opencascade::handle<StepAP214_AutoDesignActualDateAssignment>  , StepBasic_DateAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignActualDateAssignment::*)(  const handle<StepBasic_Date> & ,   const handle<StepBasic_DateRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDatedItem> &  ) ) static_cast<void (StepAP214_AutoDesignActualDateAssignment::*)(  const handle<StepBasic_Date> & ,   const handle<StepBasic_DateRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDatedItem> &  ) >(&StepAP214_AutoDesignActualDateAssignment::Init),
             R"#()#"  , py::arg("aAssignedDate"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignActualDateAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDatedItem> &  ) ) static_cast<void (StepAP214_AutoDesignActualDateAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDatedItem> &  ) >(&StepAP214_AutoDesignActualDateAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignDatedItem> (StepAP214_AutoDesignActualDateAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignDatedItem> (StepAP214_AutoDesignActualDateAssignment::*)() const>(&StepAP214_AutoDesignActualDateAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignDatedItem (StepAP214_AutoDesignActualDateAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignDatedItem (StepAP214_AutoDesignActualDateAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignActualDateAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignActualDateAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignActualDateAssignment::*)() const>(&StepAP214_AutoDesignActualDateAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignActualDateAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignActualDateAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignActualDateAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignActualDateAssignment::*)() const>(&StepAP214_AutoDesignActualDateAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignApprovalAssignment from ./opencascade/StepAP214_AutoDesignApprovalAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignApprovalAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignApprovalAssignment ,opencascade::handle<StepAP214_AutoDesignApprovalAssignment>  , StepBasic_ApprovalAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignApprovalAssignment::*)(  const handle<StepBasic_Approval> & ,   const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) ) static_cast<void (StepAP214_AutoDesignApprovalAssignment::*)(  const handle<StepBasic_Approval> & ,   const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) >(&StepAP214_AutoDesignApprovalAssignment::Init),
             R"#()#"  , py::arg("aAssignedApproval"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignApprovalAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) ) static_cast<void (StepAP214_AutoDesignApprovalAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) >(&StepAP214_AutoDesignApprovalAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> (StepAP214_AutoDesignApprovalAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> (StepAP214_AutoDesignApprovalAssignment::*)() const>(&StepAP214_AutoDesignApprovalAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignGeneralOrgItem (StepAP214_AutoDesignApprovalAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignGeneralOrgItem (StepAP214_AutoDesignApprovalAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignApprovalAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignApprovalAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignApprovalAssignment::*)() const>(&StepAP214_AutoDesignApprovalAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignApprovalAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignApprovalAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignApprovalAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignApprovalAssignment::*)() const>(&StepAP214_AutoDesignApprovalAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignDateAndPersonAssignment from ./opencascade/StepAP214_AutoDesignDateAndPersonAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignDateAndPersonAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignDateAndPersonAssignment ,opencascade::handle<StepAP214_AutoDesignDateAndPersonAssignment>  , StepBasic_PersonAndOrganizationAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignDateAndPersonAssignment::*)(  const handle<StepBasic_PersonAndOrganization> & ,   const handle<StepBasic_PersonAndOrganizationRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDateAndPersonItem> &  ) ) static_cast<void (StepAP214_AutoDesignDateAndPersonAssignment::*)(  const handle<StepBasic_PersonAndOrganization> & ,   const handle<StepBasic_PersonAndOrganizationRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDateAndPersonItem> &  ) >(&StepAP214_AutoDesignDateAndPersonAssignment::Init),
             R"#()#"  , py::arg("aAssignedPersonAndOrganization"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignDateAndPersonAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDateAndPersonItem> &  ) ) static_cast<void (StepAP214_AutoDesignDateAndPersonAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDateAndPersonItem> &  ) >(&StepAP214_AutoDesignDateAndPersonAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignDateAndPersonItem> (StepAP214_AutoDesignDateAndPersonAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignDateAndPersonItem> (StepAP214_AutoDesignDateAndPersonAssignment::*)() const>(&StepAP214_AutoDesignDateAndPersonAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignDateAndPersonItem (StepAP214_AutoDesignDateAndPersonAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignDateAndPersonItem (StepAP214_AutoDesignDateAndPersonAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignDateAndPersonAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignDateAndPersonAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignDateAndPersonAssignment::*)() const>(&StepAP214_AutoDesignDateAndPersonAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignDateAndPersonAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignDateAndPersonAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignDateAndPersonAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignDateAndPersonAssignment::*)() const>(&StepAP214_AutoDesignDateAndPersonAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignDateAndPersonItem from ./opencascade/StepAP214_AutoDesignDateAndPersonItem.hxx
    klass = m.attr("StepAP214_AutoDesignDateAndPersonItem");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignDateAndPersonItem , shared_ptr<StepAP214_AutoDesignDateAndPersonItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_AutoDesignDateAndPersonItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_AutoDesignDateAndPersonItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_AutoDesignDateAndPersonItem::CaseNum),
             R"#(Recognizes a AutoDesignDateAndPersonItem Kind Entity that is : 1 AutoDesignOrganizationAssignment from StepAP214, 2 Product from StepBasic, 3 ProductDefinition from StepBasic, 4 ProductDefinitionFormation from StepBasic, 5 Representation from StepRepr, 6 AutoDesignDocumentReference from StepAP214, 7 ExternallyDefinedRepresentation from StepRepr, 8 ProductDefinitionRelationship from StepBasic, 9 ProductDefinitionWithAssociatedDocuments from StepBasic 0 else)#"  , py::arg("ent")
          )
        .def("AutoDesignOrganizationAssignment",
             (handle<StepAP214_AutoDesignOrganizationAssignment> (StepAP214_AutoDesignDateAndPersonItem::*)() const) static_cast<handle<StepAP214_AutoDesignOrganizationAssignment> (StepAP214_AutoDesignDateAndPersonItem::*)() const>(&StepAP214_AutoDesignDateAndPersonItem::AutoDesignOrganizationAssignment),
             R"#()#" 
          )
        .def("Product",
             (handle<StepBasic_Product> (StepAP214_AutoDesignDateAndPersonItem::*)() const) static_cast<handle<StepBasic_Product> (StepAP214_AutoDesignDateAndPersonItem::*)() const>(&StepAP214_AutoDesignDateAndPersonItem::Product),
             R"#()#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepAP214_AutoDesignDateAndPersonItem::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepAP214_AutoDesignDateAndPersonItem::*)() const>(&StepAP214_AutoDesignDateAndPersonItem::ProductDefinition),
             R"#()#" 
          )
        .def("ProductDefinitionFormation",
             (handle<StepBasic_ProductDefinitionFormation> (StepAP214_AutoDesignDateAndPersonItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionFormation> (StepAP214_AutoDesignDateAndPersonItem::*)() const>(&StepAP214_AutoDesignDateAndPersonItem::ProductDefinitionFormation),
             R"#()#" 
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepAP214_AutoDesignDateAndPersonItem::*)() const) static_cast<handle<StepRepr_Representation> (StepAP214_AutoDesignDateAndPersonItem::*)() const>(&StepAP214_AutoDesignDateAndPersonItem::Representation),
             R"#()#" 
          )
        .def("AutoDesignDocumentReference",
             (handle<StepAP214_AutoDesignDocumentReference> (StepAP214_AutoDesignDateAndPersonItem::*)() const) static_cast<handle<StepAP214_AutoDesignDocumentReference> (StepAP214_AutoDesignDateAndPersonItem::*)() const>(&StepAP214_AutoDesignDateAndPersonItem::AutoDesignDocumentReference),
             R"#()#" 
          )
        .def("ExternallyDefinedRepresentation",
             (handle<StepRepr_ExternallyDefinedRepresentation> (StepAP214_AutoDesignDateAndPersonItem::*)() const) static_cast<handle<StepRepr_ExternallyDefinedRepresentation> (StepAP214_AutoDesignDateAndPersonItem::*)() const>(&StepAP214_AutoDesignDateAndPersonItem::ExternallyDefinedRepresentation),
             R"#()#" 
          )
        .def("ProductDefinitionRelationship",
             (handle<StepBasic_ProductDefinitionRelationship> (StepAP214_AutoDesignDateAndPersonItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionRelationship> (StepAP214_AutoDesignDateAndPersonItem::*)() const>(&StepAP214_AutoDesignDateAndPersonItem::ProductDefinitionRelationship),
             R"#()#" 
          )
        .def("ProductDefinitionWithAssociatedDocuments",
             (handle<StepBasic_ProductDefinitionWithAssociatedDocuments> (StepAP214_AutoDesignDateAndPersonItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionWithAssociatedDocuments> (StepAP214_AutoDesignDateAndPersonItem::*)() const>(&StepAP214_AutoDesignDateAndPersonItem::ProductDefinitionWithAssociatedDocuments),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_AutoDesignDateAndTimeItem from ./opencascade/StepAP214_AutoDesignDateAndTimeItem.hxx
    klass = m.attr("StepAP214_AutoDesignDateAndTimeItem");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignDateAndTimeItem , shared_ptr<StepAP214_AutoDesignDateAndTimeItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_AutoDesignDateAndTimeItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_AutoDesignDateAndTimeItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_AutoDesignDateAndTimeItem::CaseNum),
             R"#(Recognizes a AutoDesignDateAndTimeItem Kind Entity that is : 1 -> ApprovalPersonOrganization 2 -> AutoDesignDateAndPersonAssignment 0 else)#"  , py::arg("ent")
          )
        .def("ApprovalPersonOrganization",
             (handle<StepBasic_ApprovalPersonOrganization> (StepAP214_AutoDesignDateAndTimeItem::*)() const) static_cast<handle<StepBasic_ApprovalPersonOrganization> (StepAP214_AutoDesignDateAndTimeItem::*)() const>(&StepAP214_AutoDesignDateAndTimeItem::ApprovalPersonOrganization),
             R"#(returns Value as a ApprovalPersonOrganization (Null if another type))#" 
          )
        .def("AutoDesignDateAndPersonAssignment",
             (handle<StepAP214_AutoDesignDateAndPersonAssignment> (StepAP214_AutoDesignDateAndTimeItem::*)() const) static_cast<handle<StepAP214_AutoDesignDateAndPersonAssignment> (StepAP214_AutoDesignDateAndTimeItem::*)() const>(&StepAP214_AutoDesignDateAndTimeItem::AutoDesignDateAndPersonAssignment),
             R"#(returns Value as a AutoDesignDateAndPersonAssignment (Null if another type))#" 
          )
        .def("ProductDefinitionEffectivity",
             (handle<StepBasic_ProductDefinitionEffectivity> (StepAP214_AutoDesignDateAndTimeItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionEffectivity> (StepAP214_AutoDesignDateAndTimeItem::*)() const>(&StepAP214_AutoDesignDateAndTimeItem::ProductDefinitionEffectivity),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_AutoDesignDatedItem from ./opencascade/StepAP214_AutoDesignDatedItem.hxx
    klass = m.attr("StepAP214_AutoDesignDatedItem");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignDatedItem , shared_ptr<StepAP214_AutoDesignDatedItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_AutoDesignDatedItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_AutoDesignDatedItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_AutoDesignDatedItem::CaseNum),
             R"#(Recognizes a AutoDesignDatedItem Kind Entity that is : 1 -> ApprovalPersonOrganization 2 -> AutoDesignDateAndPersonAssignment 0 else)#"  , py::arg("ent")
          )
        .def("ApprovalPersonOrganization",
             (handle<StepBasic_ApprovalPersonOrganization> (StepAP214_AutoDesignDatedItem::*)() const) static_cast<handle<StepBasic_ApprovalPersonOrganization> (StepAP214_AutoDesignDatedItem::*)() const>(&StepAP214_AutoDesignDatedItem::ApprovalPersonOrganization),
             R"#(returns Value as a ApprovalPersonOrganization (Null if another type))#" 
          )
        .def("AutoDesignDateAndPersonAssignment",
             (handle<StepAP214_AutoDesignDateAndPersonAssignment> (StepAP214_AutoDesignDatedItem::*)() const) static_cast<handle<StepAP214_AutoDesignDateAndPersonAssignment> (StepAP214_AutoDesignDatedItem::*)() const>(&StepAP214_AutoDesignDatedItem::AutoDesignDateAndPersonAssignment),
             R"#(returns Value as a AutoDesignDateAndPersonAssignment (Null if another type))#" 
          )
        .def("ProductDefinitionEffectivity",
             (handle<StepBasic_ProductDefinitionEffectivity> (StepAP214_AutoDesignDatedItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionEffectivity> (StepAP214_AutoDesignDatedItem::*)() const>(&StepAP214_AutoDesignDatedItem::ProductDefinitionEffectivity),
             R"#(returns Value as a ProductDefinitionEffectivity)#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_AutoDesignDocumentReference from ./opencascade/StepAP214_AutoDesignDocumentReference.hxx
    klass = m.attr("StepAP214_AutoDesignDocumentReference");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignDocumentReference ,opencascade::handle<StepAP214_AutoDesignDocumentReference>  , StepBasic_DocumentReference >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignDocumentReference::*)(  const handle<StepBasic_Document> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepAP214_HArray1OfAutoDesignReferencingItem> &  ) ) static_cast<void (StepAP214_AutoDesignDocumentReference::*)(  const handle<StepBasic_Document> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepAP214_HArray1OfAutoDesignReferencingItem> &  ) >(&StepAP214_AutoDesignDocumentReference::Init),
             R"#()#"  , py::arg("aAssignedDocument"),  py::arg("aSource"),  py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignReferencingItem> (StepAP214_AutoDesignDocumentReference::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignReferencingItem> (StepAP214_AutoDesignDocumentReference::*)() const>(&StepAP214_AutoDesignDocumentReference::Items),
             R"#()#" 
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignDocumentReference::*)(  const handle<StepAP214_HArray1OfAutoDesignReferencingItem> &  ) ) static_cast<void (StepAP214_AutoDesignDocumentReference::*)(  const handle<StepAP214_HArray1OfAutoDesignReferencingItem> &  ) >(&StepAP214_AutoDesignDocumentReference::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignReferencingItem (StepAP214_AutoDesignDocumentReference::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignReferencingItem (StepAP214_AutoDesignDocumentReference::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignDocumentReference::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignDocumentReference::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignDocumentReference::*)() const>(&StepAP214_AutoDesignDocumentReference::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignDocumentReference::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignDocumentReference::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignDocumentReference::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignDocumentReference::*)() const>(&StepAP214_AutoDesignDocumentReference::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignGeneralOrgItem from ./opencascade/StepAP214_AutoDesignGeneralOrgItem.hxx
    klass = m.attr("StepAP214_AutoDesignGeneralOrgItem");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignGeneralOrgItem , shared_ptr<StepAP214_AutoDesignGeneralOrgItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_AutoDesignGeneralOrgItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_AutoDesignGeneralOrgItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_AutoDesignGeneralOrgItem::CaseNum),
             R"#(Recognizes a AutoDesignGeneralOrgItem Kind Entity that is : 1 Product from StepBasic, 2 ProductDefinition from StepBasic, 3 ProductDefinitionFormation from StepBasic, 4 ProductDefinitionRelationship from StepBasic, 5 ProductDefinitionWithAssociatedDocuments from StepBasic, 6 Representation from StepRepr 7 ExternallyDefinedRepresentation from StepRepr, 8 AutoDesignDocumentReference from StepAP214, 0 else)#"  , py::arg("ent")
          )
        .def("Product",
             (handle<StepBasic_Product> (StepAP214_AutoDesignGeneralOrgItem::*)() const) static_cast<handle<StepBasic_Product> (StepAP214_AutoDesignGeneralOrgItem::*)() const>(&StepAP214_AutoDesignGeneralOrgItem::Product),
             R"#(returns Value as a Product (Null if another type))#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepAP214_AutoDesignGeneralOrgItem::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepAP214_AutoDesignGeneralOrgItem::*)() const>(&StepAP214_AutoDesignGeneralOrgItem::ProductDefinition),
             R"#(returns Value as a ProductDefinition (Null if another type))#" 
          )
        .def("ProductDefinitionFormation",
             (handle<StepBasic_ProductDefinitionFormation> (StepAP214_AutoDesignGeneralOrgItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionFormation> (StepAP214_AutoDesignGeneralOrgItem::*)() const>(&StepAP214_AutoDesignGeneralOrgItem::ProductDefinitionFormation),
             R"#(returns Value as a ProductDefinitionFormation (Null if another type))#" 
          )
        .def("ProductDefinitionRelationship",
             (handle<StepBasic_ProductDefinitionRelationship> (StepAP214_AutoDesignGeneralOrgItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionRelationship> (StepAP214_AutoDesignGeneralOrgItem::*)() const>(&StepAP214_AutoDesignGeneralOrgItem::ProductDefinitionRelationship),
             R"#(returns Value as a ProductDefinitionRelationship (Null if another type))#" 
          )
        .def("ProductDefinitionWithAssociatedDocuments",
             (handle<StepBasic_ProductDefinitionWithAssociatedDocuments> (StepAP214_AutoDesignGeneralOrgItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionWithAssociatedDocuments> (StepAP214_AutoDesignGeneralOrgItem::*)() const>(&StepAP214_AutoDesignGeneralOrgItem::ProductDefinitionWithAssociatedDocuments),
             R"#(returns Value as a ProductDefinitionWithAssociatedDocuments (Null if another type))#" 
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepAP214_AutoDesignGeneralOrgItem::*)() const) static_cast<handle<StepRepr_Representation> (StepAP214_AutoDesignGeneralOrgItem::*)() const>(&StepAP214_AutoDesignGeneralOrgItem::Representation),
             R"#(returns Value as a Representation (Null if another type))#" 
          )
        .def("ExternallyDefinedRepresentation",
             (handle<StepRepr_ExternallyDefinedRepresentation> (StepAP214_AutoDesignGeneralOrgItem::*)() const) static_cast<handle<StepRepr_ExternallyDefinedRepresentation> (StepAP214_AutoDesignGeneralOrgItem::*)() const>(&StepAP214_AutoDesignGeneralOrgItem::ExternallyDefinedRepresentation),
             R"#(returns Value as a Representation (Null if another type))#" 
          )
        .def("AutoDesignDocumentReference",
             (handle<StepAP214_AutoDesignDocumentReference> (StepAP214_AutoDesignGeneralOrgItem::*)() const) static_cast<handle<StepAP214_AutoDesignDocumentReference> (StepAP214_AutoDesignGeneralOrgItem::*)() const>(&StepAP214_AutoDesignGeneralOrgItem::AutoDesignDocumentReference),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_AutoDesignGroupAssignment from ./opencascade/StepAP214_AutoDesignGroupAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignGroupAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignGroupAssignment ,opencascade::handle<StepAP214_AutoDesignGroupAssignment>  , StepBasic_GroupAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignGroupAssignment::*)(  const handle<StepBasic_Group> & ,   const handle<StepAP214_HArray1OfAutoDesignGroupedItem> &  ) ) static_cast<void (StepAP214_AutoDesignGroupAssignment::*)(  const handle<StepBasic_Group> & ,   const handle<StepAP214_HArray1OfAutoDesignGroupedItem> &  ) >(&StepAP214_AutoDesignGroupAssignment::Init),
             R"#()#"  , py::arg("aAssignedGroup"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignGroupAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignGroupedItem> &  ) ) static_cast<void (StepAP214_AutoDesignGroupAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignGroupedItem> &  ) >(&StepAP214_AutoDesignGroupAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignGroupedItem> (StepAP214_AutoDesignGroupAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignGroupedItem> (StepAP214_AutoDesignGroupAssignment::*)() const>(&StepAP214_AutoDesignGroupAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignGroupedItem (StepAP214_AutoDesignGroupAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignGroupedItem (StepAP214_AutoDesignGroupAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignGroupAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignGroupAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignGroupAssignment::*)() const>(&StepAP214_AutoDesignGroupAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignGroupAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignGroupAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignGroupAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignGroupAssignment::*)() const>(&StepAP214_AutoDesignGroupAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignGroupedItem from ./opencascade/StepAP214_AutoDesignGroupedItem.hxx
    klass = m.attr("StepAP214_AutoDesignGroupedItem");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignGroupedItem , shared_ptr<StepAP214_AutoDesignGroupedItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_AutoDesignGroupedItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_AutoDesignGroupedItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_AutoDesignGroupedItem::CaseNum),
             R"#(Recognizes a AutoDesignGroupedItem Kind Entity that is : 1 -> AdvancedBrepShapeRepresentation 2 -> CsgShapeRepresentation 3 -> FacetedBrepShapeRepresentation 4 -> GeometricallyBoundedSurfaceShapeRepresentation 5 -> GeometricallyBoundedWireframeShapeRepresentation 6 -> ManifoldSurfaceShapeRepresentation 7 -> Representation 8 -> RepresentationItem 9 -> ShapeAspect 10 -> ShapeRepresentation 11 -> TemplateInstance 0 else)#"  , py::arg("ent")
          )
        .def("AdvancedBrepShapeRepresentation",
             (handle<StepShape_AdvancedBrepShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepShape_AdvancedBrepShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::AdvancedBrepShapeRepresentation),
             R"#(returns Value as a AdvancedBrepShapeRepresentation (Null if another type))#" 
          )
        .def("CsgShapeRepresentation",
             (handle<StepShape_CsgShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepShape_CsgShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::CsgShapeRepresentation),
             R"#(returns Value as a CsgShapeRepresentation (Null if another type))#" 
          )
        .def("FacetedBrepShapeRepresentation",
             (handle<StepShape_FacetedBrepShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepShape_FacetedBrepShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::FacetedBrepShapeRepresentation),
             R"#(returns Value as a FacetedBrepShapeRepresentation (Null if another type))#" 
          )
        .def("GeometricallyBoundedSurfaceShapeRepresentation",
             (handle<StepShape_GeometricallyBoundedSurfaceShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepShape_GeometricallyBoundedSurfaceShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::GeometricallyBoundedSurfaceShapeRepresentation),
             R"#(returns Value as a GeometricallyBoundedSurfaceShapeRepresentation (Null if another type))#" 
          )
        .def("GeometricallyBoundedWireframeShapeRepresentation",
             (handle<StepShape_GeometricallyBoundedWireframeShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepShape_GeometricallyBoundedWireframeShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::GeometricallyBoundedWireframeShapeRepresentation),
             R"#(returns Value as a GeometricallyBoundedWireframeShapeRepresentation (Null if another type))#" 
          )
        .def("ManifoldSurfaceShapeRepresentation",
             (handle<StepShape_ManifoldSurfaceShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepShape_ManifoldSurfaceShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::ManifoldSurfaceShapeRepresentation),
             R"#(returns Value as a ManifoldSurfaceShapeRepresentation (Null if another type))#" 
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepRepr_Representation> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::Representation),
             R"#(returns Value as a Representation (Null if another type))#" 
          )
        .def("RepresentationItem",
             (handle<StepRepr_RepresentationItem> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::RepresentationItem),
             R"#(returns Value as a RepresentationItem (Null if another type))#" 
          )
        .def("ShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::ShapeAspect),
             R"#(returns Value as a ShapeAspect (Null if another type))#" 
          )
        .def("ShapeRepresentation",
             (handle<StepShape_ShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepShape_ShapeRepresentation> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::ShapeRepresentation),
             R"#(returns Value as a ShapeRepresentation (Null if another type))#" 
          )
        .def("TemplateInstance",
             (handle<StepVisual_TemplateInstance> (StepAP214_AutoDesignGroupedItem::*)() const) static_cast<handle<StepVisual_TemplateInstance> (StepAP214_AutoDesignGroupedItem::*)() const>(&StepAP214_AutoDesignGroupedItem::TemplateInstance),
             R"#(returns Value as a TemplateInstance (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_AutoDesignNominalDateAndTimeAssignment from ./opencascade/StepAP214_AutoDesignNominalDateAndTimeAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignNominalDateAndTimeAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignNominalDateAndTimeAssignment ,opencascade::handle<StepAP214_AutoDesignNominalDateAndTimeAssignment>  , StepBasic_DateAndTimeAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)(  const handle<StepBasic_DateAndTime> & ,   const handle<StepBasic_DateTimeRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> &  ) ) static_cast<void (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)(  const handle<StepBasic_DateAndTime> & ,   const handle<StepBasic_DateTimeRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> &  ) >(&StepAP214_AutoDesignNominalDateAndTimeAssignment::Init),
             R"#()#"  , py::arg("aAssignedDateAndTime"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> &  ) ) static_cast<void (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> &  ) >(&StepAP214_AutoDesignNominalDateAndTimeAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem> (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)() const>(&StepAP214_AutoDesignNominalDateAndTimeAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignDateAndTimeItem (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignDateAndTimeItem (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignNominalDateAndTimeAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)() const>(&StepAP214_AutoDesignNominalDateAndTimeAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignNominalDateAndTimeAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignNominalDateAndTimeAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignNominalDateAndTimeAssignment::*)() const>(&StepAP214_AutoDesignNominalDateAndTimeAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignNominalDateAssignment from ./opencascade/StepAP214_AutoDesignNominalDateAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignNominalDateAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignNominalDateAssignment ,opencascade::handle<StepAP214_AutoDesignNominalDateAssignment>  , StepBasic_DateAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignNominalDateAssignment::*)(  const handle<StepBasic_Date> & ,   const handle<StepBasic_DateRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDatedItem> &  ) ) static_cast<void (StepAP214_AutoDesignNominalDateAssignment::*)(  const handle<StepBasic_Date> & ,   const handle<StepBasic_DateRole> & ,   const handle<StepAP214_HArray1OfAutoDesignDatedItem> &  ) >(&StepAP214_AutoDesignNominalDateAssignment::Init),
             R"#()#"  , py::arg("aAssignedDate"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignNominalDateAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDatedItem> &  ) ) static_cast<void (StepAP214_AutoDesignNominalDateAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignDatedItem> &  ) >(&StepAP214_AutoDesignNominalDateAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignDatedItem> (StepAP214_AutoDesignNominalDateAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignDatedItem> (StepAP214_AutoDesignNominalDateAssignment::*)() const>(&StepAP214_AutoDesignNominalDateAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignDatedItem (StepAP214_AutoDesignNominalDateAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignDatedItem (StepAP214_AutoDesignNominalDateAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignNominalDateAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignNominalDateAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignNominalDateAssignment::*)() const>(&StepAP214_AutoDesignNominalDateAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignNominalDateAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignNominalDateAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignNominalDateAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignNominalDateAssignment::*)() const>(&StepAP214_AutoDesignNominalDateAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignOrganizationAssignment from ./opencascade/StepAP214_AutoDesignOrganizationAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignOrganizationAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignOrganizationAssignment ,opencascade::handle<StepAP214_AutoDesignOrganizationAssignment>  , StepBasic_OrganizationAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignOrganizationAssignment::*)(  const handle<StepBasic_Organization> & ,   const handle<StepBasic_OrganizationRole> & ,   const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) ) static_cast<void (StepAP214_AutoDesignOrganizationAssignment::*)(  const handle<StepBasic_Organization> & ,   const handle<StepBasic_OrganizationRole> & ,   const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) >(&StepAP214_AutoDesignOrganizationAssignment::Init),
             R"#()#"  , py::arg("aAssignedOrganization"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignOrganizationAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) ) static_cast<void (StepAP214_AutoDesignOrganizationAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) >(&StepAP214_AutoDesignOrganizationAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> (StepAP214_AutoDesignOrganizationAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> (StepAP214_AutoDesignOrganizationAssignment::*)() const>(&StepAP214_AutoDesignOrganizationAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignGeneralOrgItem (StepAP214_AutoDesignOrganizationAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignGeneralOrgItem (StepAP214_AutoDesignOrganizationAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignOrganizationAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignOrganizationAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignOrganizationAssignment::*)() const>(&StepAP214_AutoDesignOrganizationAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignOrganizationAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignOrganizationAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignOrganizationAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignOrganizationAssignment::*)() const>(&StepAP214_AutoDesignOrganizationAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignPersonAndOrganizationAssignment from ./opencascade/StepAP214_AutoDesignPersonAndOrganizationAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignPersonAndOrganizationAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignPersonAndOrganizationAssignment ,opencascade::handle<StepAP214_AutoDesignPersonAndOrganizationAssignment>  , StepBasic_PersonAndOrganizationAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)(  const handle<StepBasic_PersonAndOrganization> & ,   const handle<StepBasic_PersonAndOrganizationRole> & ,   const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) ) static_cast<void (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)(  const handle<StepBasic_PersonAndOrganization> & ,   const handle<StepBasic_PersonAndOrganizationRole> & ,   const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) >(&StepAP214_AutoDesignPersonAndOrganizationAssignment::Init),
             R"#()#"  , py::arg("aAssignedPersonAndOrganization"),  py::arg("aRole"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) ) static_cast<void (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)(  const handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> &  ) >(&StepAP214_AutoDesignPersonAndOrganizationAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem> (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)() const>(&StepAP214_AutoDesignPersonAndOrganizationAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignGeneralOrgItem (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignGeneralOrgItem (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignPersonAndOrganizationAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)() const>(&StepAP214_AutoDesignPersonAndOrganizationAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignPersonAndOrganizationAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignPersonAndOrganizationAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignPersonAndOrganizationAssignment::*)() const>(&StepAP214_AutoDesignPersonAndOrganizationAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignPresentedItem from ./opencascade/StepAP214_AutoDesignPresentedItem.hxx
    klass = m.attr("StepAP214_AutoDesignPresentedItem");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignPresentedItem ,opencascade::handle<StepAP214_AutoDesignPresentedItem>  , StepVisual_PresentedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignPresentedItem::*)(  const handle<StepAP214_HArray1OfAutoDesignPresentedItemSelect> &  ) ) static_cast<void (StepAP214_AutoDesignPresentedItem::*)(  const handle<StepAP214_HArray1OfAutoDesignPresentedItemSelect> &  ) >(&StepAP214_AutoDesignPresentedItem::Init),
             R"#()#"  , py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignPresentedItem::*)(  const handle<StepAP214_HArray1OfAutoDesignPresentedItemSelect> &  ) ) static_cast<void (StepAP214_AutoDesignPresentedItem::*)(  const handle<StepAP214_HArray1OfAutoDesignPresentedItemSelect> &  ) >(&StepAP214_AutoDesignPresentedItem::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepAP214_HArray1OfAutoDesignPresentedItemSelect> (StepAP214_AutoDesignPresentedItem::*)() const) static_cast<handle<StepAP214_HArray1OfAutoDesignPresentedItemSelect> (StepAP214_AutoDesignPresentedItem::*)() const>(&StepAP214_AutoDesignPresentedItem::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (StepAP214_AutoDesignPresentedItemSelect (StepAP214_AutoDesignPresentedItem::*)(  const Standard_Integer  ) const) static_cast<StepAP214_AutoDesignPresentedItemSelect (StepAP214_AutoDesignPresentedItem::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignPresentedItem::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignPresentedItem::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignPresentedItem::*)() const>(&StepAP214_AutoDesignPresentedItem::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignPresentedItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignPresentedItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignPresentedItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignPresentedItem::*)() const>(&StepAP214_AutoDesignPresentedItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignPresentedItemSelect from ./opencascade/StepAP214_AutoDesignPresentedItemSelect.hxx
    klass = m.attr("StepAP214_AutoDesignPresentedItemSelect");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignPresentedItemSelect , shared_ptr<StepAP214_AutoDesignPresentedItemSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_AutoDesignPresentedItemSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_AutoDesignPresentedItemSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_AutoDesignPresentedItemSelect::CaseNum),
             R"#(Recognizes a AutoDesignPresentedItemSelect Kind Entity that is : 1 -> ProductDefinition, 2 -> ProductDefinitionRelationship, 3 -> ProductDefinitionShape 4 -> RepresentationRelationship 5 -> ShapeAspect 6 -> DocumentRelationship, 0 else)#"  , py::arg("ent")
          )
        .def("ProductDefinitionRelationship",
             (handle<StepBasic_ProductDefinitionRelationship> (StepAP214_AutoDesignPresentedItemSelect::*)() const) static_cast<handle<StepBasic_ProductDefinitionRelationship> (StepAP214_AutoDesignPresentedItemSelect::*)() const>(&StepAP214_AutoDesignPresentedItemSelect::ProductDefinitionRelationship),
             R"#(returns Value as a ProductDefinitionRelationship (Null if another type))#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepAP214_AutoDesignPresentedItemSelect::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepAP214_AutoDesignPresentedItemSelect::*)() const>(&StepAP214_AutoDesignPresentedItemSelect::ProductDefinition),
             R"#(returns Value as a ProductDefinition (Null if another type))#" 
          )
        .def("ProductDefinitionShape",
             (handle<StepRepr_ProductDefinitionShape> (StepAP214_AutoDesignPresentedItemSelect::*)() const) static_cast<handle<StepRepr_ProductDefinitionShape> (StepAP214_AutoDesignPresentedItemSelect::*)() const>(&StepAP214_AutoDesignPresentedItemSelect::ProductDefinitionShape),
             R"#(returns Value as a ProductDefinitionShape (Null if another type))#" 
          )
        .def("RepresentationRelationship",
             (handle<StepRepr_RepresentationRelationship> (StepAP214_AutoDesignPresentedItemSelect::*)() const) static_cast<handle<StepRepr_RepresentationRelationship> (StepAP214_AutoDesignPresentedItemSelect::*)() const>(&StepAP214_AutoDesignPresentedItemSelect::RepresentationRelationship),
             R"#(returns Value as a RepresentationRelationship (Null if another type))#" 
          )
        .def("ShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepAP214_AutoDesignPresentedItemSelect::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepAP214_AutoDesignPresentedItemSelect::*)() const>(&StepAP214_AutoDesignPresentedItemSelect::ShapeAspect),
             R"#(returns Value as a ShapeAspect (Null if another type))#" 
          )
        .def("DocumentRelationship",
             (handle<StepBasic_DocumentRelationship> (StepAP214_AutoDesignPresentedItemSelect::*)() const) static_cast<handle<StepBasic_DocumentRelationship> (StepAP214_AutoDesignPresentedItemSelect::*)() const>(&StepAP214_AutoDesignPresentedItemSelect::DocumentRelationship),
             R"#(returns Value as a DocumentRelationship (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_AutoDesignReferencingItem from ./opencascade/StepAP214_AutoDesignReferencingItem.hxx
    klass = m.attr("StepAP214_AutoDesignReferencingItem");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignReferencingItem , shared_ptr<StepAP214_AutoDesignReferencingItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_AutoDesignReferencingItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_AutoDesignReferencingItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_AutoDesignReferencingItem::CaseNum),
             R"#(Recognizes a AutoDesignReferencingItem Kind Entity that is : 1 Approval from StepBasic, 2 DocumentRelationship from StepBasic, 3 ExternallyDefinedRepresentation from StepRepr, 4 MappedItem from StepRepr, 5 MaterialDesignation from StepRepr, 6 PresentationArea from StepVisual, 7 PresentationView from StepVisual, 8 ProductCategory from StepBasic, 9 ProductDefinition from StepBasic, 10 ProductDefinitionRelationship from StepBasic, 11 PropertyDefinition from StepBasic, 12 Representation from StepRepr, 13 RepresentationRelationship from StepRepr, 14 ShapeAspect from StepRepr 0 else)#"  , py::arg("ent")
          )
        .def("Approval",
             (handle<StepBasic_Approval> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepBasic_Approval> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::Approval),
             R"#()#" 
          )
        .def("DocumentRelationship",
             (handle<StepBasic_DocumentRelationship> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepBasic_DocumentRelationship> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::DocumentRelationship),
             R"#()#" 
          )
        .def("ExternallyDefinedRepresentation",
             (handle<StepRepr_ExternallyDefinedRepresentation> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepRepr_ExternallyDefinedRepresentation> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::ExternallyDefinedRepresentation),
             R"#()#" 
          )
        .def("MappedItem",
             (handle<StepRepr_MappedItem> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepRepr_MappedItem> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::MappedItem),
             R"#()#" 
          )
        .def("MaterialDesignation",
             (handle<StepRepr_MaterialDesignation> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepRepr_MaterialDesignation> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::MaterialDesignation),
             R"#()#" 
          )
        .def("PresentationArea",
             (handle<StepVisual_PresentationArea> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepVisual_PresentationArea> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::PresentationArea),
             R"#()#" 
          )
        .def("PresentationView",
             (handle<StepVisual_PresentationView> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepVisual_PresentationView> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::PresentationView),
             R"#()#" 
          )
        .def("ProductCategory",
             (handle<StepBasic_ProductCategory> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepBasic_ProductCategory> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::ProductCategory),
             R"#()#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::ProductDefinition),
             R"#()#" 
          )
        .def("ProductDefinitionRelationship",
             (handle<StepBasic_ProductDefinitionRelationship> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionRelationship> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::ProductDefinitionRelationship),
             R"#()#" 
          )
        .def("PropertyDefinition",
             (handle<StepRepr_PropertyDefinition> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepRepr_PropertyDefinition> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::PropertyDefinition),
             R"#()#" 
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepRepr_Representation> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::Representation),
             R"#()#" 
          )
        .def("RepresentationRelationship",
             (handle<StepRepr_RepresentationRelationship> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepRepr_RepresentationRelationship> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::RepresentationRelationship),
             R"#()#" 
          )
        .def("ShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepAP214_AutoDesignReferencingItem::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepAP214_AutoDesignReferencingItem::*)() const>(&StepAP214_AutoDesignReferencingItem::ShapeAspect),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_AutoDesignSecurityClassificationAssignment from ./opencascade/StepAP214_AutoDesignSecurityClassificationAssignment.hxx
    klass = m.attr("StepAP214_AutoDesignSecurityClassificationAssignment");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignSecurityClassificationAssignment ,opencascade::handle<StepAP214_AutoDesignSecurityClassificationAssignment>  , StepBasic_SecurityClassificationAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_AutoDesignSecurityClassificationAssignment::*)(  const handle<StepBasic_SecurityClassification> & ,   const handle<StepBasic_HArray1OfApproval> &  ) ) static_cast<void (StepAP214_AutoDesignSecurityClassificationAssignment::*)(  const handle<StepBasic_SecurityClassification> & ,   const handle<StepBasic_HArray1OfApproval> &  ) >(&StepAP214_AutoDesignSecurityClassificationAssignment::Init),
             R"#()#"  , py::arg("aAssignedSecurityClassification"),  py::arg("aItems")
          )
        .def("SetItems",
             (void (StepAP214_AutoDesignSecurityClassificationAssignment::*)(  const handle<StepBasic_HArray1OfApproval> &  ) ) static_cast<void (StepAP214_AutoDesignSecurityClassificationAssignment::*)(  const handle<StepBasic_HArray1OfApproval> &  ) >(&StepAP214_AutoDesignSecurityClassificationAssignment::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepBasic_HArray1OfApproval> (StepAP214_AutoDesignSecurityClassificationAssignment::*)() const) static_cast<handle<StepBasic_HArray1OfApproval> (StepAP214_AutoDesignSecurityClassificationAssignment::*)() const>(&StepAP214_AutoDesignSecurityClassificationAssignment::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (handle<StepBasic_Approval> (StepAP214_AutoDesignSecurityClassificationAssignment::*)(  const Standard_Integer  ) const) static_cast<handle<StepBasic_Approval> (StepAP214_AutoDesignSecurityClassificationAssignment::*)(  const Standard_Integer  ) const>(&StepAP214_AutoDesignSecurityClassificationAssignment::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepAP214_AutoDesignSecurityClassificationAssignment::*)() const) static_cast<Standard_Integer (StepAP214_AutoDesignSecurityClassificationAssignment::*)() const>(&StepAP214_AutoDesignSecurityClassificationAssignment::NbItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_AutoDesignSecurityClassificationAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_AutoDesignSecurityClassificationAssignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_AutoDesignSecurityClassificationAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_AutoDesignSecurityClassificationAssignment::*)() const>(&StepAP214_AutoDesignSecurityClassificationAssignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_Class from ./opencascade/StepAP214_Class.hxx
    klass = m.attr("StepAP214_Class");


    // nested enums

    static_cast<py::class_<StepAP214_Class ,opencascade::handle<StepAP214_Class>  , StepBasic_Group >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_Class::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_Class::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_Class::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_Class::*)() const>(&StepAP214_Class::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_DocumentReferenceItem from ./opencascade/StepAP214_DocumentReferenceItem.hxx
    klass = m.attr("StepAP214_DocumentReferenceItem");


    // nested enums

    static_cast<py::class_<StepAP214_DocumentReferenceItem , shared_ptr<StepAP214_DocumentReferenceItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_DocumentReferenceItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_DocumentReferenceItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_DocumentReferenceItem::CaseNum),
             R"#(Recognizes a DocumentReferenceItem Kind Entity that is :)#"  , py::arg("ent")
          )
        .def("Approval",
             (handle<StepBasic_Approval> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepBasic_Approval> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::Approval),
             R"#(returns Value as a Approval (Null if another type))#" 
          )
        .def("DescriptiveRepresentationItem",
             (handle<StepRepr_DescriptiveRepresentationItem> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepRepr_DescriptiveRepresentationItem> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::DescriptiveRepresentationItem),
             R"#(returns Value as a (Null if another type))#" 
          )
        .def("MaterialDesignation",
             (handle<StepRepr_MaterialDesignation> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepRepr_MaterialDesignation> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::MaterialDesignation),
             R"#(returns Value as a MaterialDesignation (Null if another type))#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::ProductDefinition),
             R"#(returns Value as a ProductDefinition (Null if another type))#" 
          )
        .def("ProductDefinitionRelationship",
             (handle<StepBasic_ProductDefinitionRelationship> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionRelationship> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::ProductDefinitionRelationship),
             R"#(returns Value as aProductDefinitionRelationship (Null if another type))#" 
          )
        .def("PropertyDefinition",
             (handle<StepRepr_PropertyDefinition> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepRepr_PropertyDefinition> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::PropertyDefinition),
             R"#(returns Value as a PropertyDefinition (Null if another type))#" 
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepRepr_Representation> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::Representation),
             R"#(returns Value as a Representation (Null if another type))#" 
          )
        .def("ShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::ShapeAspect),
             R"#(returns Value as a ShapeAspect (Null if another type))#" 
          )
        .def("ShapeAspectRelationship",
             (handle<StepRepr_ShapeAspectRelationship> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepRepr_ShapeAspectRelationship> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::ShapeAspectRelationship),
             R"#(returns Value as a ShapeAspectRelationship (Null if another type))#" 
          )
        .def("AppliedExternalIdentificationAssignment",
             (handle<StepAP214_AppliedExternalIdentificationAssignment> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepAP214_AppliedExternalIdentificationAssignment> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::AppliedExternalIdentificationAssignment),
             R"#(returns Value as a AppliedExternalIdentificationAssignment (Null if another type))#" 
          )
        .def("AssemblyComponentUsage",
             (handle<StepRepr_AssemblyComponentUsage> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepRepr_AssemblyComponentUsage> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::AssemblyComponentUsage),
             R"#(returns Value as a AssemblyComponentUsage (Null if another type))#" 
          )
        .def("CharacterizedObject",
             (handle<StepBasic_CharacterizedObject> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepBasic_CharacterizedObject> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::CharacterizedObject),
             R"#(returns Value as a CharacterizedObject (Null if another type))#" 
          )
        .def("DimensionalSize",
             (handle<StepShape_DimensionalSize> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepShape_DimensionalSize> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::DimensionalSize),
             R"#(returns Value as a DimensionalSize (Null if another type))#" 
          )
        .def("ExternallyDefinedItem",
             (handle<StepBasic_ExternallyDefinedItem> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepBasic_ExternallyDefinedItem> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::ExternallyDefinedItem),
             R"#(returns Value as a ExternallyDefinedItem (Null if another type))#" 
          )
        .def("Group",
             (handle<StepBasic_Group> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepBasic_Group> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::Group),
             R"#(returns Value as a Group (Null if another type))#" 
          )
        .def("GroupRelationship",
             (handle<StepBasic_GroupRelationship> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepBasic_GroupRelationship> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::GroupRelationship),
             R"#(returns Value as a GroupRelationship (Null if another type))#" 
          )
        .def("MeasureRepresentationItem",
             (handle<StepRepr_MeasureRepresentationItem> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepRepr_MeasureRepresentationItem> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::MeasureRepresentationItem),
             R"#(returns Value as a MeasureRepresentationItem (Null if another type))#" 
          )
        .def("ProductCategory",
             (handle<StepBasic_ProductCategory> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepBasic_ProductCategory> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::ProductCategory),
             R"#(returns Value as a ProductCategory (Null if another type))#" 
          )
        .def("ProductDefinitionContext",
             (handle<StepBasic_ProductDefinitionContext> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionContext> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::ProductDefinitionContext),
             R"#(returns Value as a ProductDefinitionContext (Null if another type))#" 
          )
        .def("RepresentationItem",
             (handle<StepRepr_RepresentationItem> (StepAP214_DocumentReferenceItem::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepAP214_DocumentReferenceItem::*)() const>(&StepAP214_DocumentReferenceItem::RepresentationItem),
             R"#(returns Value as a RepresentationItem (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_ExternalIdentificationItem from ./opencascade/StepAP214_ExternalIdentificationItem.hxx
    klass = m.attr("StepAP214_ExternalIdentificationItem");


    // nested enums

    static_cast<py::class_<StepAP214_ExternalIdentificationItem , shared_ptr<StepAP214_ExternalIdentificationItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_ExternalIdentificationItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_ExternalIdentificationItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_ExternalIdentificationItem::CaseNum),
             R"#(Recognizes a kind of ExternalIdentificationItem select type 1 -> DocumentFile from StepBasic 2 -> ExternallyDefinedClass from StepAP214 3 -> ExternallyDefinedGeneralProperty from StepAP214 4 -> ProductDefinition from StepBasic 5 -> AppliedOrganizationAssignment from AP214 6 -> AppliedPersonAndOrganizationAssignment from AP214 7 -> Approval from StepBasic 8 -> ApprovalStatus from StepBasic 9 -> ExternalSource from StepBasic 10 -> OrganizationalAddress from StepBasic 11 -> SecurityClassification from StepBasic 12 -> TrimmedCurve from StepGeom 13 -> VersionedActionRequest from StepBasic 14 -> DateAndTimeAssignment from StepBasic 15 -> DateAssignment from StepBasic 0 else)#"  , py::arg("ent")
          )
        .def("DocumentFile",
             (handle<StepBasic_DocumentFile> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_DocumentFile> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::DocumentFile),
             R"#(Returns Value as DocumentFile (or Null if another type))#" 
          )
        .def("ExternallyDefinedClass",
             (handle<StepAP214_ExternallyDefinedClass> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepAP214_ExternallyDefinedClass> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::ExternallyDefinedClass),
             R"#(Returns Value as ExternallyDefinedClass (or Null if another type))#" 
          )
        .def("ExternallyDefinedGeneralProperty",
             (handle<StepAP214_ExternallyDefinedGeneralProperty> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepAP214_ExternallyDefinedGeneralProperty> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::ExternallyDefinedGeneralProperty),
             R"#(Returns Value as ExternallyDefinedGeneralProperty (or Null if another type))#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::ProductDefinition),
             R"#(Returns Value as ProductDefinition (or Null if another type))#" 
          )
        .def("AppliedOrganizationAssignment",
             (handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::AppliedOrganizationAssignment),
             R"#(Returns Value as AppliedOrganizationAssignment (or Null if another type))#" 
          )
        .def("AppliedPersonAndOrganizationAssignment",
             (handle<StepAP214_AppliedPersonAndOrganizationAssignment> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepAP214_AppliedPersonAndOrganizationAssignment> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::AppliedPersonAndOrganizationAssignment),
             R"#(Returns Value as AppliedPersonAndOrganizationAssignment (or Null if another type))#" 
          )
        .def("Approval",
             (handle<StepBasic_Approval> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_Approval> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::Approval),
             R"#(Returns Value as Approval (or Null if another type))#" 
          )
        .def("ApprovalStatus",
             (handle<StepBasic_ApprovalStatus> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_ApprovalStatus> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::ApprovalStatus),
             R"#(Returns Value as ApprovalStatus (or Null if another type))#" 
          )
        .def("ExternalSource",
             (handle<StepBasic_ExternalSource> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_ExternalSource> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::ExternalSource),
             R"#(Returns Value as ExternalSource (or Null if another type))#" 
          )
        .def("OrganizationalAddress",
             (handle<StepBasic_OrganizationalAddress> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_OrganizationalAddress> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::OrganizationalAddress),
             R"#(Returns Value as OrganizationalAddress (or Null if another type))#" 
          )
        .def("SecurityClassification",
             (handle<StepBasic_SecurityClassification> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_SecurityClassification> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::SecurityClassification),
             R"#(Returns Value as SecurityClassification (or Null if another type))#" 
          )
        .def("TrimmedCurve",
             (handle<StepGeom_TrimmedCurve> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepGeom_TrimmedCurve> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::TrimmedCurve),
             R"#(Returns Value as TrimmedCurve (or Null if another type))#" 
          )
        .def("VersionedActionRequest",
             (handle<StepBasic_VersionedActionRequest> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_VersionedActionRequest> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::VersionedActionRequest),
             R"#(Returns Value as VersionedActionRequest (or Null if another type))#" 
          )
        .def("DateAndTimeAssignment",
             (handle<StepBasic_DateAndTimeAssignment> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_DateAndTimeAssignment> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::DateAndTimeAssignment),
             R"#(Returns Value as DateAndTimeAssignment (or Null if another type))#" 
          )
        .def("DateAssignment",
             (handle<StepBasic_DateAssignment> (StepAP214_ExternalIdentificationItem::*)() const) static_cast<handle<StepBasic_DateAssignment> (StepAP214_ExternalIdentificationItem::*)() const>(&StepAP214_ExternalIdentificationItem::DateAssignment),
             R"#(Returns Value as DateAssignment (or Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_ExternallyDefinedGeneralProperty from ./opencascade/StepAP214_ExternallyDefinedGeneralProperty.hxx
    klass = m.attr("StepAP214_ExternallyDefinedGeneralProperty");


    // nested enums

    static_cast<py::class_<StepAP214_ExternallyDefinedGeneralProperty ,opencascade::handle<StepAP214_ExternallyDefinedGeneralProperty>  , StepBasic_GeneralProperty >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_ExternallyDefinedGeneralProperty::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_SourceItem & ,   const handle<StepBasic_ExternalSource> &  ) ) static_cast<void (StepAP214_ExternallyDefinedGeneralProperty::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_SourceItem & ,   const handle<StepBasic_ExternalSource> &  ) >(&StepAP214_ExternallyDefinedGeneralProperty::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aGeneralProperty_Id"),  py::arg("aGeneralProperty_Name"),  py::arg("hasGeneralProperty_Description"),  py::arg("aGeneralProperty_Description"),  py::arg("aExternallyDefinedItem_ItemId"),  py::arg("aExternallyDefinedItem_Source")
          )
        .def("ExternallyDefinedItem",
             (handle<StepBasic_ExternallyDefinedItem> (StepAP214_ExternallyDefinedGeneralProperty::*)() const) static_cast<handle<StepBasic_ExternallyDefinedItem> (StepAP214_ExternallyDefinedGeneralProperty::*)() const>(&StepAP214_ExternallyDefinedGeneralProperty::ExternallyDefinedItem),
             R"#(Returns data for supertype ExternallyDefinedItem)#" 
          )
        .def("SetExternallyDefinedItem",
             (void (StepAP214_ExternallyDefinedGeneralProperty::*)(  const handle<StepBasic_ExternallyDefinedItem> &  ) ) static_cast<void (StepAP214_ExternallyDefinedGeneralProperty::*)(  const handle<StepBasic_ExternallyDefinedItem> &  ) >(&StepAP214_ExternallyDefinedGeneralProperty::SetExternallyDefinedItem),
             R"#(Set data for supertype ExternallyDefinedItem)#"  , py::arg("ExternallyDefinedItem")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_ExternallyDefinedGeneralProperty::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_ExternallyDefinedGeneralProperty::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_ExternallyDefinedGeneralProperty::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_ExternallyDefinedGeneralProperty::*)() const>(&StepAP214_ExternallyDefinedGeneralProperty::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_GroupItem from ./opencascade/StepAP214_GroupItem.hxx
    klass = m.attr("StepAP214_GroupItem");


    // nested enums

    static_cast<py::class_<StepAP214_GroupItem , shared_ptr<StepAP214_GroupItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_GroupItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_GroupItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_GroupItem::CaseNum),
             R"#(Recognizes a GroupItem Kind Entity that is : 1 -> GeometricRepresentationItem 2 -> GroupRelationship 3 -> MappedItem 4 -> ProductDefinition 5 -> ProductDefinitionFormation 6 -> PropertyDefinitionRepresentation 7 -> Representation 8 -> RepresentationItem 9 -> RepresentationRelationshipWithTransformation 10 -> ShapeAspect 11 -> ShapeAspectRelationship 12 -> ShapeRepresentationRelationship 13 -> StyledItem 14 -> TopologicalRepresentationItem 0 else)#"  , py::arg("ent")
          )
        .def("GeometricRepresentationItem",
             (handle<StepGeom_GeometricRepresentationItem> (StepAP214_GroupItem::*)() const) static_cast<handle<StepGeom_GeometricRepresentationItem> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::GeometricRepresentationItem),
             R"#(returns Value as a GeometricRepresentationItem (Null if another type))#" 
          )
        .def("GroupRelationship",
             (handle<StepBasic_GroupRelationship> (StepAP214_GroupItem::*)() const) static_cast<handle<StepBasic_GroupRelationship> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::GroupRelationship),
             R"#(returns Value as a GroupRelationship (Null if another type))#" 
          )
        .def("MappedItem",
             (handle<StepRepr_MappedItem> (StepAP214_GroupItem::*)() const) static_cast<handle<StepRepr_MappedItem> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::MappedItem),
             R"#(returns Value as a MappedItem (Null if another type))#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepAP214_GroupItem::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::ProductDefinition),
             R"#(returns Value as a ProductDefinition (Null if another type))#" 
          )
        .def("ProductDefinitionFormation",
             (handle<StepBasic_ProductDefinitionFormation> (StepAP214_GroupItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionFormation> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::ProductDefinitionFormation),
             R"#(returns Value as a ProductDefinitionFormation (Null if another type))#" 
          )
        .def("PropertyDefinitionRepresentation",
             (handle<StepRepr_PropertyDefinitionRepresentation> (StepAP214_GroupItem::*)() const) static_cast<handle<StepRepr_PropertyDefinitionRepresentation> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::PropertyDefinitionRepresentation),
             R"#(returns Value as a PropertyDefinitionRepresentation (Null if another type))#" 
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepAP214_GroupItem::*)() const) static_cast<handle<StepRepr_Representation> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::Representation),
             R"#(returns Value as a Representation (Null if another type))#" 
          )
        .def("RepresentationItem",
             (handle<StepRepr_RepresentationItem> (StepAP214_GroupItem::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::RepresentationItem),
             R"#(returns Value as a RepresentationItem (Null if another type))#" 
          )
        .def("RepresentationRelationshipWithTransformation",
             (handle<StepRepr_RepresentationRelationshipWithTransformation> (StepAP214_GroupItem::*)() const) static_cast<handle<StepRepr_RepresentationRelationshipWithTransformation> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::RepresentationRelationshipWithTransformation),
             R"#(returns Value as a RepresentationRelationshipWithTransformation (Null if another type))#" 
          )
        .def("ShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepAP214_GroupItem::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::ShapeAspect),
             R"#(returns Value as a ShapeAspect (Null if another type))#" 
          )
        .def("ShapeAspectRelationship",
             (handle<StepRepr_ShapeAspectRelationship> (StepAP214_GroupItem::*)() const) static_cast<handle<StepRepr_ShapeAspectRelationship> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::ShapeAspectRelationship),
             R"#(returns Value as a ShapeAspectRelationship (Null if another type))#" 
          )
        .def("ShapeRepresentationRelationship",
             (handle<StepRepr_ShapeRepresentationRelationship> (StepAP214_GroupItem::*)() const) static_cast<handle<StepRepr_ShapeRepresentationRelationship> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::ShapeRepresentationRelationship),
             R"#(returns Value as a ShapeRepresentationRelationship (Null if another type))#" 
          )
        .def("StyledItem",
             (handle<StepVisual_StyledItem> (StepAP214_GroupItem::*)() const) static_cast<handle<StepVisual_StyledItem> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::StyledItem),
             R"#(returns Value as a StyledItem (Null if another type))#" 
          )
        .def("TopologicalRepresentationItem",
             (handle<StepShape_TopologicalRepresentationItem> (StepAP214_GroupItem::*)() const) static_cast<handle<StepShape_TopologicalRepresentationItem> (StepAP214_GroupItem::*)() const>(&StepAP214_GroupItem::TopologicalRepresentationItem),
             R"#(returns Value as a TopologicalRepresentationItem (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_HArray1OfApprovalItem from ./opencascade/StepAP214_HArray1OfApprovalItem.hxx
    klass = m.attr("StepAP214_HArray1OfApprovalItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfApprovalItem ,opencascade::handle<StepAP214_HArray1OfApprovalItem>  , StepAP214_Array1OfApprovalItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_ApprovalItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_ApprovalItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfApprovalItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfApprovalItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfApprovalItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfApprovalItem & (StepAP214_HArray1OfApprovalItem::*)() const) static_cast< const StepAP214_Array1OfApprovalItem & (StepAP214_HArray1OfApprovalItem::*)() const>(&StepAP214_HArray1OfApprovalItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfApprovalItem & (StepAP214_HArray1OfApprovalItem::*)() ) static_cast<StepAP214_Array1OfApprovalItem & (StepAP214_HArray1OfApprovalItem::*)() >(&StepAP214_HArray1OfApprovalItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfApprovalItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfApprovalItem::*)() const>(&StepAP214_HArray1OfApprovalItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfAutoDesignDateAndPersonItem from ./opencascade/StepAP214_HArray1OfAutoDesignDateAndPersonItem.hxx
    klass = m.attr("StepAP214_HArray1OfAutoDesignDateAndPersonItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfAutoDesignDateAndPersonItem ,opencascade::handle<StepAP214_HArray1OfAutoDesignDateAndPersonItem>  , StepAP214_Array1OfAutoDesignDateAndPersonItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_AutoDesignDateAndPersonItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_AutoDesignDateAndPersonItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfAutoDesignDateAndPersonItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfAutoDesignDateAndPersonItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfAutoDesignDateAndPersonItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfAutoDesignDateAndPersonItem & (StepAP214_HArray1OfAutoDesignDateAndPersonItem::*)() const) static_cast< const StepAP214_Array1OfAutoDesignDateAndPersonItem & (StepAP214_HArray1OfAutoDesignDateAndPersonItem::*)() const>(&StepAP214_HArray1OfAutoDesignDateAndPersonItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfAutoDesignDateAndPersonItem & (StepAP214_HArray1OfAutoDesignDateAndPersonItem::*)() ) static_cast<StepAP214_Array1OfAutoDesignDateAndPersonItem & (StepAP214_HArray1OfAutoDesignDateAndPersonItem::*)() >(&StepAP214_HArray1OfAutoDesignDateAndPersonItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignDateAndPersonItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignDateAndPersonItem::*)() const>(&StepAP214_HArray1OfAutoDesignDateAndPersonItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfAutoDesignDateAndTimeItem from ./opencascade/StepAP214_HArray1OfAutoDesignDateAndTimeItem.hxx
    klass = m.attr("StepAP214_HArray1OfAutoDesignDateAndTimeItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfAutoDesignDateAndTimeItem ,opencascade::handle<StepAP214_HArray1OfAutoDesignDateAndTimeItem>  , StepAP214_Array1OfAutoDesignDateAndTimeItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_AutoDesignDateAndTimeItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_AutoDesignDateAndTimeItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfAutoDesignDateAndTimeItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfAutoDesignDateAndTimeItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfAutoDesignDateAndTimeItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfAutoDesignDateAndTimeItem & (StepAP214_HArray1OfAutoDesignDateAndTimeItem::*)() const) static_cast< const StepAP214_Array1OfAutoDesignDateAndTimeItem & (StepAP214_HArray1OfAutoDesignDateAndTimeItem::*)() const>(&StepAP214_HArray1OfAutoDesignDateAndTimeItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfAutoDesignDateAndTimeItem & (StepAP214_HArray1OfAutoDesignDateAndTimeItem::*)() ) static_cast<StepAP214_Array1OfAutoDesignDateAndTimeItem & (StepAP214_HArray1OfAutoDesignDateAndTimeItem::*)() >(&StepAP214_HArray1OfAutoDesignDateAndTimeItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignDateAndTimeItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignDateAndTimeItem::*)() const>(&StepAP214_HArray1OfAutoDesignDateAndTimeItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfAutoDesignDatedItem from ./opencascade/StepAP214_HArray1OfAutoDesignDatedItem.hxx
    klass = m.attr("StepAP214_HArray1OfAutoDesignDatedItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfAutoDesignDatedItem ,opencascade::handle<StepAP214_HArray1OfAutoDesignDatedItem>  , StepAP214_Array1OfAutoDesignDatedItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_AutoDesignDatedItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_AutoDesignDatedItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfAutoDesignDatedItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfAutoDesignDatedItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfAutoDesignDatedItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfAutoDesignDatedItem & (StepAP214_HArray1OfAutoDesignDatedItem::*)() const) static_cast< const StepAP214_Array1OfAutoDesignDatedItem & (StepAP214_HArray1OfAutoDesignDatedItem::*)() const>(&StepAP214_HArray1OfAutoDesignDatedItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfAutoDesignDatedItem & (StepAP214_HArray1OfAutoDesignDatedItem::*)() ) static_cast<StepAP214_Array1OfAutoDesignDatedItem & (StepAP214_HArray1OfAutoDesignDatedItem::*)() >(&StepAP214_HArray1OfAutoDesignDatedItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignDatedItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignDatedItem::*)() const>(&StepAP214_HArray1OfAutoDesignDatedItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfAutoDesignGeneralOrgItem from ./opencascade/StepAP214_HArray1OfAutoDesignGeneralOrgItem.hxx
    klass = m.attr("StepAP214_HArray1OfAutoDesignGeneralOrgItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfAutoDesignGeneralOrgItem ,opencascade::handle<StepAP214_HArray1OfAutoDesignGeneralOrgItem>  , StepAP214_Array1OfAutoDesignGeneralOrgItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_AutoDesignGeneralOrgItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_AutoDesignGeneralOrgItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfAutoDesignGeneralOrgItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfAutoDesignGeneralOrgItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfAutoDesignGeneralOrgItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfAutoDesignGeneralOrgItem & (StepAP214_HArray1OfAutoDesignGeneralOrgItem::*)() const) static_cast< const StepAP214_Array1OfAutoDesignGeneralOrgItem & (StepAP214_HArray1OfAutoDesignGeneralOrgItem::*)() const>(&StepAP214_HArray1OfAutoDesignGeneralOrgItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfAutoDesignGeneralOrgItem & (StepAP214_HArray1OfAutoDesignGeneralOrgItem::*)() ) static_cast<StepAP214_Array1OfAutoDesignGeneralOrgItem & (StepAP214_HArray1OfAutoDesignGeneralOrgItem::*)() >(&StepAP214_HArray1OfAutoDesignGeneralOrgItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignGeneralOrgItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignGeneralOrgItem::*)() const>(&StepAP214_HArray1OfAutoDesignGeneralOrgItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfAutoDesignGroupedItem from ./opencascade/StepAP214_HArray1OfAutoDesignGroupedItem.hxx
    klass = m.attr("StepAP214_HArray1OfAutoDesignGroupedItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfAutoDesignGroupedItem ,opencascade::handle<StepAP214_HArray1OfAutoDesignGroupedItem>  , StepAP214_Array1OfAutoDesignGroupedItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_AutoDesignGroupedItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_AutoDesignGroupedItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfAutoDesignGroupedItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfAutoDesignGroupedItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfAutoDesignGroupedItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfAutoDesignGroupedItem & (StepAP214_HArray1OfAutoDesignGroupedItem::*)() const) static_cast< const StepAP214_Array1OfAutoDesignGroupedItem & (StepAP214_HArray1OfAutoDesignGroupedItem::*)() const>(&StepAP214_HArray1OfAutoDesignGroupedItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfAutoDesignGroupedItem & (StepAP214_HArray1OfAutoDesignGroupedItem::*)() ) static_cast<StepAP214_Array1OfAutoDesignGroupedItem & (StepAP214_HArray1OfAutoDesignGroupedItem::*)() >(&StepAP214_HArray1OfAutoDesignGroupedItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignGroupedItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignGroupedItem::*)() const>(&StepAP214_HArray1OfAutoDesignGroupedItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfAutoDesignPresentedItemSelect from ./opencascade/StepAP214_HArray1OfAutoDesignPresentedItemSelect.hxx
    klass = m.attr("StepAP214_HArray1OfAutoDesignPresentedItemSelect");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfAutoDesignPresentedItemSelect ,opencascade::handle<StepAP214_HArray1OfAutoDesignPresentedItemSelect>  , StepAP214_Array1OfAutoDesignPresentedItemSelect , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_AutoDesignPresentedItemSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_AutoDesignPresentedItemSelect>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfAutoDesignPresentedItemSelect & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfAutoDesignPresentedItemSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfAutoDesignPresentedItemSelect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfAutoDesignPresentedItemSelect & (StepAP214_HArray1OfAutoDesignPresentedItemSelect::*)() const) static_cast< const StepAP214_Array1OfAutoDesignPresentedItemSelect & (StepAP214_HArray1OfAutoDesignPresentedItemSelect::*)() const>(&StepAP214_HArray1OfAutoDesignPresentedItemSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfAutoDesignPresentedItemSelect & (StepAP214_HArray1OfAutoDesignPresentedItemSelect::*)() ) static_cast<StepAP214_Array1OfAutoDesignPresentedItemSelect & (StepAP214_HArray1OfAutoDesignPresentedItemSelect::*)() >(&StepAP214_HArray1OfAutoDesignPresentedItemSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignPresentedItemSelect::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignPresentedItemSelect::*)() const>(&StepAP214_HArray1OfAutoDesignPresentedItemSelect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfAutoDesignReferencingItem from ./opencascade/StepAP214_HArray1OfAutoDesignReferencingItem.hxx
    klass = m.attr("StepAP214_HArray1OfAutoDesignReferencingItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfAutoDesignReferencingItem ,opencascade::handle<StepAP214_HArray1OfAutoDesignReferencingItem>  , StepAP214_Array1OfAutoDesignReferencingItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_AutoDesignReferencingItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_AutoDesignReferencingItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfAutoDesignReferencingItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfAutoDesignReferencingItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfAutoDesignReferencingItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfAutoDesignReferencingItem & (StepAP214_HArray1OfAutoDesignReferencingItem::*)() const) static_cast< const StepAP214_Array1OfAutoDesignReferencingItem & (StepAP214_HArray1OfAutoDesignReferencingItem::*)() const>(&StepAP214_HArray1OfAutoDesignReferencingItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfAutoDesignReferencingItem & (StepAP214_HArray1OfAutoDesignReferencingItem::*)() ) static_cast<StepAP214_Array1OfAutoDesignReferencingItem & (StepAP214_HArray1OfAutoDesignReferencingItem::*)() >(&StepAP214_HArray1OfAutoDesignReferencingItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignReferencingItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfAutoDesignReferencingItem::*)() const>(&StepAP214_HArray1OfAutoDesignReferencingItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfDateAndTimeItem from ./opencascade/StepAP214_HArray1OfDateAndTimeItem.hxx
    klass = m.attr("StepAP214_HArray1OfDateAndTimeItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfDateAndTimeItem ,opencascade::handle<StepAP214_HArray1OfDateAndTimeItem>  , StepAP214_Array1OfDateAndTimeItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_DateAndTimeItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_DateAndTimeItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfDateAndTimeItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfDateAndTimeItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfDateAndTimeItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfDateAndTimeItem & (StepAP214_HArray1OfDateAndTimeItem::*)() const) static_cast< const StepAP214_Array1OfDateAndTimeItem & (StepAP214_HArray1OfDateAndTimeItem::*)() const>(&StepAP214_HArray1OfDateAndTimeItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfDateAndTimeItem & (StepAP214_HArray1OfDateAndTimeItem::*)() ) static_cast<StepAP214_Array1OfDateAndTimeItem & (StepAP214_HArray1OfDateAndTimeItem::*)() >(&StepAP214_HArray1OfDateAndTimeItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfDateAndTimeItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfDateAndTimeItem::*)() const>(&StepAP214_HArray1OfDateAndTimeItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfDateItem from ./opencascade/StepAP214_HArray1OfDateItem.hxx
    klass = m.attr("StepAP214_HArray1OfDateItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfDateItem ,opencascade::handle<StepAP214_HArray1OfDateItem>  , StepAP214_Array1OfDateItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_DateItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_DateItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfDateItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfDateItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfDateItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfDateItem & (StepAP214_HArray1OfDateItem::*)() const) static_cast< const StepAP214_Array1OfDateItem & (StepAP214_HArray1OfDateItem::*)() const>(&StepAP214_HArray1OfDateItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfDateItem & (StepAP214_HArray1OfDateItem::*)() ) static_cast<StepAP214_Array1OfDateItem & (StepAP214_HArray1OfDateItem::*)() >(&StepAP214_HArray1OfDateItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfDateItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfDateItem::*)() const>(&StepAP214_HArray1OfDateItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfDocumentReferenceItem from ./opencascade/StepAP214_HArray1OfDocumentReferenceItem.hxx
    klass = m.attr("StepAP214_HArray1OfDocumentReferenceItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfDocumentReferenceItem ,opencascade::handle<StepAP214_HArray1OfDocumentReferenceItem>  , StepAP214_Array1OfDocumentReferenceItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_DocumentReferenceItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_DocumentReferenceItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfDocumentReferenceItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfDocumentReferenceItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfDocumentReferenceItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfDocumentReferenceItem & (StepAP214_HArray1OfDocumentReferenceItem::*)() const) static_cast< const StepAP214_Array1OfDocumentReferenceItem & (StepAP214_HArray1OfDocumentReferenceItem::*)() const>(&StepAP214_HArray1OfDocumentReferenceItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfDocumentReferenceItem & (StepAP214_HArray1OfDocumentReferenceItem::*)() ) static_cast<StepAP214_Array1OfDocumentReferenceItem & (StepAP214_HArray1OfDocumentReferenceItem::*)() >(&StepAP214_HArray1OfDocumentReferenceItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfDocumentReferenceItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfDocumentReferenceItem::*)() const>(&StepAP214_HArray1OfDocumentReferenceItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfExternalIdentificationItem from ./opencascade/StepAP214_HArray1OfExternalIdentificationItem.hxx
    klass = m.attr("StepAP214_HArray1OfExternalIdentificationItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfExternalIdentificationItem ,opencascade::handle<StepAP214_HArray1OfExternalIdentificationItem>  , StepAP214_Array1OfExternalIdentificationItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_ExternalIdentificationItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_ExternalIdentificationItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfExternalIdentificationItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfExternalIdentificationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfExternalIdentificationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfExternalIdentificationItem & (StepAP214_HArray1OfExternalIdentificationItem::*)() const) static_cast< const StepAP214_Array1OfExternalIdentificationItem & (StepAP214_HArray1OfExternalIdentificationItem::*)() const>(&StepAP214_HArray1OfExternalIdentificationItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfExternalIdentificationItem & (StepAP214_HArray1OfExternalIdentificationItem::*)() ) static_cast<StepAP214_Array1OfExternalIdentificationItem & (StepAP214_HArray1OfExternalIdentificationItem::*)() >(&StepAP214_HArray1OfExternalIdentificationItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfExternalIdentificationItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfExternalIdentificationItem::*)() const>(&StepAP214_HArray1OfExternalIdentificationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfGroupItem from ./opencascade/StepAP214_HArray1OfGroupItem.hxx
    klass = m.attr("StepAP214_HArray1OfGroupItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfGroupItem ,opencascade::handle<StepAP214_HArray1OfGroupItem>  , StepAP214_Array1OfGroupItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_GroupItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_GroupItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfGroupItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfGroupItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfGroupItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfGroupItem & (StepAP214_HArray1OfGroupItem::*)() const) static_cast< const StepAP214_Array1OfGroupItem & (StepAP214_HArray1OfGroupItem::*)() const>(&StepAP214_HArray1OfGroupItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfGroupItem & (StepAP214_HArray1OfGroupItem::*)() ) static_cast<StepAP214_Array1OfGroupItem & (StepAP214_HArray1OfGroupItem::*)() >(&StepAP214_HArray1OfGroupItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfGroupItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfGroupItem::*)() const>(&StepAP214_HArray1OfGroupItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfOrganizationItem from ./opencascade/StepAP214_HArray1OfOrganizationItem.hxx
    klass = m.attr("StepAP214_HArray1OfOrganizationItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfOrganizationItem ,opencascade::handle<StepAP214_HArray1OfOrganizationItem>  , StepAP214_Array1OfOrganizationItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_OrganizationItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_OrganizationItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfOrganizationItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfOrganizationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfOrganizationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfOrganizationItem & (StepAP214_HArray1OfOrganizationItem::*)() const) static_cast< const StepAP214_Array1OfOrganizationItem & (StepAP214_HArray1OfOrganizationItem::*)() const>(&StepAP214_HArray1OfOrganizationItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfOrganizationItem & (StepAP214_HArray1OfOrganizationItem::*)() ) static_cast<StepAP214_Array1OfOrganizationItem & (StepAP214_HArray1OfOrganizationItem::*)() >(&StepAP214_HArray1OfOrganizationItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfOrganizationItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfOrganizationItem::*)() const>(&StepAP214_HArray1OfOrganizationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfPersonAndOrganizationItem from ./opencascade/StepAP214_HArray1OfPersonAndOrganizationItem.hxx
    klass = m.attr("StepAP214_HArray1OfPersonAndOrganizationItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfPersonAndOrganizationItem ,opencascade::handle<StepAP214_HArray1OfPersonAndOrganizationItem>  , StepAP214_Array1OfPersonAndOrganizationItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_PersonAndOrganizationItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_PersonAndOrganizationItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfPersonAndOrganizationItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfPersonAndOrganizationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfPersonAndOrganizationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfPersonAndOrganizationItem & (StepAP214_HArray1OfPersonAndOrganizationItem::*)() const) static_cast< const StepAP214_Array1OfPersonAndOrganizationItem & (StepAP214_HArray1OfPersonAndOrganizationItem::*)() const>(&StepAP214_HArray1OfPersonAndOrganizationItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfPersonAndOrganizationItem & (StepAP214_HArray1OfPersonAndOrganizationItem::*)() ) static_cast<StepAP214_Array1OfPersonAndOrganizationItem & (StepAP214_HArray1OfPersonAndOrganizationItem::*)() >(&StepAP214_HArray1OfPersonAndOrganizationItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfPersonAndOrganizationItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfPersonAndOrganizationItem::*)() const>(&StepAP214_HArray1OfPersonAndOrganizationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfPresentedItemSelect from ./opencascade/StepAP214_HArray1OfPresentedItemSelect.hxx
    klass = m.attr("StepAP214_HArray1OfPresentedItemSelect");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfPresentedItemSelect ,opencascade::handle<StepAP214_HArray1OfPresentedItemSelect>  , StepAP214_Array1OfPresentedItemSelect , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_PresentedItemSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_PresentedItemSelect>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfPresentedItemSelect & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfPresentedItemSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfPresentedItemSelect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfPresentedItemSelect & (StepAP214_HArray1OfPresentedItemSelect::*)() const) static_cast< const StepAP214_Array1OfPresentedItemSelect & (StepAP214_HArray1OfPresentedItemSelect::*)() const>(&StepAP214_HArray1OfPresentedItemSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfPresentedItemSelect & (StepAP214_HArray1OfPresentedItemSelect::*)() ) static_cast<StepAP214_Array1OfPresentedItemSelect & (StepAP214_HArray1OfPresentedItemSelect::*)() >(&StepAP214_HArray1OfPresentedItemSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfPresentedItemSelect::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfPresentedItemSelect::*)() const>(&StepAP214_HArray1OfPresentedItemSelect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_HArray1OfSecurityClassificationItem from ./opencascade/StepAP214_HArray1OfSecurityClassificationItem.hxx
    klass = m.attr("StepAP214_HArray1OfSecurityClassificationItem");


    // nested enums

    static_cast<py::class_<StepAP214_HArray1OfSecurityClassificationItem ,opencascade::handle<StepAP214_HArray1OfSecurityClassificationItem>  , StepAP214_Array1OfSecurityClassificationItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<StepAP214_SecurityClassificationItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepAP214_SecurityClassificationItem>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepAP214_Array1OfSecurityClassificationItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_HArray1OfSecurityClassificationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_HArray1OfSecurityClassificationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepAP214_Array1OfSecurityClassificationItem & (StepAP214_HArray1OfSecurityClassificationItem::*)() const) static_cast< const StepAP214_Array1OfSecurityClassificationItem & (StepAP214_HArray1OfSecurityClassificationItem::*)() const>(&StepAP214_HArray1OfSecurityClassificationItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepAP214_Array1OfSecurityClassificationItem & (StepAP214_HArray1OfSecurityClassificationItem::*)() ) static_cast<StepAP214_Array1OfSecurityClassificationItem & (StepAP214_HArray1OfSecurityClassificationItem::*)() >(&StepAP214_HArray1OfSecurityClassificationItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_HArray1OfSecurityClassificationItem::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_HArray1OfSecurityClassificationItem::*)() const>(&StepAP214_HArray1OfSecurityClassificationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_PresentedItemSelect from ./opencascade/StepAP214_PresentedItemSelect.hxx
    klass = m.attr("StepAP214_PresentedItemSelect");


    // nested enums

    static_cast<py::class_<StepAP214_PresentedItemSelect , shared_ptr<StepAP214_PresentedItemSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_PresentedItemSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_PresentedItemSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_PresentedItemSelect::CaseNum),
             R"#(Recognizes a PresentedItemSelect Kind Entity that is : 1 -> ProductDefinition, 2 -> ProductDefinitionRelationship, 0 else)#"  , py::arg("ent")
          )
        .def("ProductDefinitionRelationship",
             (handle<StepBasic_ProductDefinitionRelationship> (StepAP214_PresentedItemSelect::*)() const) static_cast<handle<StepBasic_ProductDefinitionRelationship> (StepAP214_PresentedItemSelect::*)() const>(&StepAP214_PresentedItemSelect::ProductDefinitionRelationship),
             R"#(returns Value as a ProductDefinitionRelationship (Null if another type))#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepAP214_PresentedItemSelect::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepAP214_PresentedItemSelect::*)() const>(&StepAP214_PresentedItemSelect::ProductDefinition),
             R"#(returns Value as a ProductDefinition (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_Protocol from ./opencascade/StepAP214_Protocol.hxx
    klass = m.attr("StepAP214_Protocol");


    // nested enums

    static_cast<py::class_<StepAP214_Protocol ,opencascade::handle<StepAP214_Protocol>  , StepData_Protocol >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("TypeNumber",
             (Standard_Integer (StepAP214_Protocol::*)(  const handle<Standard_Type> &  ) const) static_cast<Standard_Integer (StepAP214_Protocol::*)(  const handle<Standard_Type> &  ) const>(&StepAP214_Protocol::TypeNumber),
             R"#(Returns a Case Number for each of the StepAP214 Entities)#"  , py::arg("atype")
          )
        .def("SchemaName",
             (Standard_CString (StepAP214_Protocol::*)(  const handle<Interface_InterfaceModel> &  ) const) static_cast<Standard_CString (StepAP214_Protocol::*)(  const handle<Interface_InterfaceModel> &  ) const>(&StepAP214_Protocol::SchemaName),
             R"#()#"  , py::arg("theModel")
          )
        .def("NbResources",
             (Standard_Integer (StepAP214_Protocol::*)() const) static_cast<Standard_Integer (StepAP214_Protocol::*)() const>(&StepAP214_Protocol::NbResources),
             R"#(Returns count of Protocol used as Resources (level one))#" 
          )
        .def("Resource",
             (handle<Interface_Protocol> (StepAP214_Protocol::*)(  const Standard_Integer  ) const) static_cast<handle<Interface_Protocol> (StepAP214_Protocol::*)(  const Standard_Integer  ) const>(&StepAP214_Protocol::Resource),
             R"#(Returns a Resource, given its rank (between 1 and NbResources))#"  , py::arg("num")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_Protocol::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_Protocol::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_Protocol::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_Protocol::*)() const>(&StepAP214_Protocol::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_RepItemGroup from ./opencascade/StepAP214_RepItemGroup.hxx
    klass = m.attr("StepAP214_RepItemGroup");


    // nested enums

    static_cast<py::class_<StepAP214_RepItemGroup ,opencascade::handle<StepAP214_RepItemGroup>  , StepBasic_Group >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_RepItemGroup::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepAP214_RepItemGroup::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> &  ) >(&StepAP214_RepItemGroup::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aGroup_Name"),  py::arg("hasGroup_Description"),  py::arg("aGroup_Description"),  py::arg("aRepresentationItem_Name")
          )
        .def("RepresentationItem",
             (handle<StepRepr_RepresentationItem> (StepAP214_RepItemGroup::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepAP214_RepItemGroup::*)() const>(&StepAP214_RepItemGroup::RepresentationItem),
             R"#(Returns data for supertype RepresentationItem)#" 
          )
        .def("SetRepresentationItem",
             (void (StepAP214_RepItemGroup::*)(  const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepAP214_RepItemGroup::*)(  const handle<StepRepr_RepresentationItem> &  ) >(&StepAP214_RepItemGroup::SetRepresentationItem),
             R"#(Set data for supertype RepresentationItem)#"  , py::arg("RepresentationItem")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_RepItemGroup::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_RepItemGroup::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_RepItemGroup::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_RepItemGroup::*)() const>(&StepAP214_RepItemGroup::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_AutoDesignOrganizationItem from ./opencascade/StepAP214_AutoDesignOrganizationItem.hxx
    klass = m.attr("StepAP214_AutoDesignOrganizationItem");


    // nested enums

    static_cast<py::class_<StepAP214_AutoDesignOrganizationItem , shared_ptr<StepAP214_AutoDesignOrganizationItem>  , StepAP214_AutoDesignGeneralOrgItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_AutoDesignOrganizationItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_AutoDesignOrganizationItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_AutoDesignOrganizationItem::CaseNum),
             R"#()#"  , py::arg("ent")
          )
        .def("Document",
             (handle<StepBasic_Document> (StepAP214_AutoDesignOrganizationItem::*)() const) static_cast<handle<StepBasic_Document> (StepAP214_AutoDesignOrganizationItem::*)() const>(&StepAP214_AutoDesignOrganizationItem::Document),
             R"#()#" 
          )
        .def("PhysicallyModeledProductDefinition",
             (handle<StepBasic_PhysicallyModeledProductDefinition> (StepAP214_AutoDesignOrganizationItem::*)() const) static_cast<handle<StepBasic_PhysicallyModeledProductDefinition> (StepAP214_AutoDesignOrganizationItem::*)() const>(&StepAP214_AutoDesignOrganizationItem::PhysicallyModeledProductDefinition),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_DateAndTimeItem from ./opencascade/StepAP214_DateAndTimeItem.hxx
    klass = m.attr("StepAP214_DateAndTimeItem");


    // nested enums

    static_cast<py::class_<StepAP214_DateAndTimeItem , shared_ptr<StepAP214_DateAndTimeItem>  , StepAP214_ApprovalItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_DateAndTimeItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_DateAndTimeItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_DateAndTimeItem::CaseNum),
             R"#(Recognizes a DateAndTimeItem Kind Entity that is : 1 -> ApprovalPersonOrganization 2 -> AppliedDateAndPersonAssignment 3 -> AppliedOrganizationAssignment 4 -> AssemblyComponentUsageSubstitute 5 -> DocumentFile 6 -> Effectivity 7 -> MaterialDesignation 8 -> MechanicalDesignGeometricPresentationRepresentation 9 -> PresentationArea 10 -> Product 11 -> ProductDefinition 12 -> ProductDefinitionFormation 13 -> ProductDefinitionRelationship 14 -> PropertyDefinition 15 -> ShapeRepresentation 16 -> SecurityClassification 0 else)#"  , py::arg("ent")
          )
        .def("ApprovalPersonOrganization",
             (handle<StepBasic_ApprovalPersonOrganization> (StepAP214_DateAndTimeItem::*)() const) static_cast<handle<StepBasic_ApprovalPersonOrganization> (StepAP214_DateAndTimeItem::*)() const>(&StepAP214_DateAndTimeItem::ApprovalPersonOrganization),
             R"#(returns Value as a ApprovalPersonOrganization (Null if another type))#" 
          )
        .def("AppliedPersonAndOrganizationAssignment",
             (handle<StepAP214_AppliedPersonAndOrganizationAssignment> (StepAP214_DateAndTimeItem::*)() const) static_cast<handle<StepAP214_AppliedPersonAndOrganizationAssignment> (StepAP214_DateAndTimeItem::*)() const>(&StepAP214_DateAndTimeItem::AppliedPersonAndOrganizationAssignment),
             R"#(returns Value as a AppliedDateAndPersonAssignment (Null if another type))#" 
          )
        .def("AppliedOrganizationAssignment",
             (handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_DateAndTimeItem::*)() const) static_cast<handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_DateAndTimeItem::*)() const>(&StepAP214_DateAndTimeItem::AppliedOrganizationAssignment),
             R"#(returns Value as a AppliedOrganizationAssignment (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_DateItem from ./opencascade/StepAP214_DateItem.hxx
    klass = m.attr("StepAP214_DateItem");


    // nested enums

    static_cast<py::class_<StepAP214_DateItem , shared_ptr<StepAP214_DateItem>  , StepAP214_ApprovalItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_DateItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_DateItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_DateItem::CaseNum),
             R"#(Recognizes a DateItem Kind Entity that is : 1 -> ApprovalPersonOrganization 2 -> AppliedDateAndPersonAssignment 3 -> AppliedOrganizationAssignment 4 -> AssemblyComponentUsageSubstitute 5 -> DocumentFile 6 -> Effectivity 7 -> MaterialDesignation 8 -> MechanicalDesignGeometricPresentationRepresentation 9 -> PresentationArea 10 -> Product 11 -> ProductDefinition 12 -> ProductDefinitionFormation 13 -> ProductDefinitionRelationship 14 -> PropertyDefinition 15 -> ShapeRepresentation 16 -> AppliedSecurityClassificationAssignment 17 -> Document 0 else)#"  , py::arg("ent")
          )
        .def("ApprovalPersonOrganization",
             (handle<StepBasic_ApprovalPersonOrganization> (StepAP214_DateItem::*)() const) static_cast<handle<StepBasic_ApprovalPersonOrganization> (StepAP214_DateItem::*)() const>(&StepAP214_DateItem::ApprovalPersonOrganization),
             R"#(returns Value as a ApprovalPersonOrganization (Null if another type))#" 
          )
        .def("AppliedPersonAndOrganizationAssignment",
             (handle<StepAP214_AppliedPersonAndOrganizationAssignment> (StepAP214_DateItem::*)() const) static_cast<handle<StepAP214_AppliedPersonAndOrganizationAssignment> (StepAP214_DateItem::*)() const>(&StepAP214_DateItem::AppliedPersonAndOrganizationAssignment),
             R"#(returns Value as a AppliedDateAndPersonAssignment (Null if another type))#" 
          )
        .def("AppliedOrganizationAssignment",
             (handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_DateItem::*)() const) static_cast<handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_DateItem::*)() const>(&StepAP214_DateItem::AppliedOrganizationAssignment),
             R"#(returns Value as a AppliedOrganizationAssignment (Null if another type))#" 
          )
        .def("AppliedSecurityClassificationAssignment",
             (handle<StepAP214_AppliedSecurityClassificationAssignment> (StepAP214_DateItem::*)() const) static_cast<handle<StepAP214_AppliedSecurityClassificationAssignment> (StepAP214_DateItem::*)() const>(&StepAP214_DateItem::AppliedSecurityClassificationAssignment),
             R"#(returns Value as a AppliedSecurityClassificationAssignment (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_ExternallyDefinedClass from ./opencascade/StepAP214_ExternallyDefinedClass.hxx
    klass = m.attr("StepAP214_ExternallyDefinedClass");


    // nested enums

    static_cast<py::class_<StepAP214_ExternallyDefinedClass ,opencascade::handle<StepAP214_ExternallyDefinedClass>  , StepAP214_Class >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepAP214_ExternallyDefinedClass::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_SourceItem & ,   const handle<StepBasic_ExternalSource> &  ) ) static_cast<void (StepAP214_ExternallyDefinedClass::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_SourceItem & ,   const handle<StepBasic_ExternalSource> &  ) >(&StepAP214_ExternallyDefinedClass::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aGroup_Name"),  py::arg("hasGroup_Description"),  py::arg("aGroup_Description"),  py::arg("aExternallyDefinedItem_ItemId"),  py::arg("aExternallyDefinedItem_Source")
          )
        .def("ExternallyDefinedItem",
             (handle<StepBasic_ExternallyDefinedItem> (StepAP214_ExternallyDefinedClass::*)() const) static_cast<handle<StepBasic_ExternallyDefinedItem> (StepAP214_ExternallyDefinedClass::*)() const>(&StepAP214_ExternallyDefinedClass::ExternallyDefinedItem),
             R"#(Returns data for supertype ExternallyDefinedItem)#" 
          )
        .def("SetExternallyDefinedItem",
             (void (StepAP214_ExternallyDefinedClass::*)(  const handle<StepBasic_ExternallyDefinedItem> &  ) ) static_cast<void (StepAP214_ExternallyDefinedClass::*)(  const handle<StepBasic_ExternallyDefinedItem> &  ) >(&StepAP214_ExternallyDefinedClass::SetExternallyDefinedItem),
             R"#(Set data for supertype ExternallyDefinedItem)#"  , py::arg("ExternallyDefinedItem")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepAP214_ExternallyDefinedClass::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepAP214_ExternallyDefinedClass::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepAP214_ExternallyDefinedClass::*)() const) static_cast< const handle<Standard_Type> & (StepAP214_ExternallyDefinedClass::*)() const>(&StepAP214_ExternallyDefinedClass::DynamicType),
             R"#()#"
             
         )
;

    // Class StepAP214_OrganizationItem from ./opencascade/StepAP214_OrganizationItem.hxx
    klass = m.attr("StepAP214_OrganizationItem");


    // nested enums

    static_cast<py::class_<StepAP214_OrganizationItem , shared_ptr<StepAP214_OrganizationItem>  , StepAP214_ApprovalItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_OrganizationItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_OrganizationItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_OrganizationItem::CaseNum),
             R"#(Recognizes a OrganizationItem Kind Entity that is :)#"  , py::arg("ent")
          )
        .def("AppliedOrganizationAssignment",
             (handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_OrganizationItem::*)() const) static_cast<handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_OrganizationItem::*)() const>(&StepAP214_OrganizationItem::AppliedOrganizationAssignment),
             R"#(returns Value as a AppliedOrganizationAssignment (Null if another type))#" 
          )
        .def("Approval",
             (handle<StepBasic_Approval> (StepAP214_OrganizationItem::*)() const) static_cast<handle<StepBasic_Approval> (StepAP214_OrganizationItem::*)() const>(&StepAP214_OrganizationItem::Approval),
             R"#(returns Value as a Approval (Null if another type))#" 
          )
        .def("AppliedSecurityClassificationAssignment",
             (handle<StepAP214_AppliedSecurityClassificationAssignment> (StepAP214_OrganizationItem::*)() const) static_cast<handle<StepAP214_AppliedSecurityClassificationAssignment> (StepAP214_OrganizationItem::*)() const>(&StepAP214_OrganizationItem::AppliedSecurityClassificationAssignment),
             R"#(returns Value as a AppliedSecurityClassificationAssignment (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_PersonAndOrganizationItem from ./opencascade/StepAP214_PersonAndOrganizationItem.hxx
    klass = m.attr("StepAP214_PersonAndOrganizationItem");


    // nested enums

    static_cast<py::class_<StepAP214_PersonAndOrganizationItem , shared_ptr<StepAP214_PersonAndOrganizationItem>  , StepAP214_ApprovalItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_PersonAndOrganizationItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_PersonAndOrganizationItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_PersonAndOrganizationItem::CaseNum),
             R"#(Recognizes a APersonAndOrganizationItem Kind Entity that is : 1 -> AppliedOrganizationAssignment 2 -> AssemblyComponentUsageSubstitute 3 -> DocumentFile 4 -> MaterialDesignation 5 -> MechanicalDesignGeometricPresentationRepresentation 6 -> PresentationArea 7 -> Product 8 -> ProductDefinition 9 -> ProductDefinitionFormation 10 -> ProductDefinitionRelationship 11 -> PropertyDefinition 12 -> ShapeRepresentation 13 -> SecurityClassification 14 -> AppliedSecurityClassificationAssignment 15 -> Approval 0 else)#"  , py::arg("ent")
          )
        .def("AppliedOrganizationAssignment",
             (handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_PersonAndOrganizationItem::*)() const) static_cast<handle<StepAP214_AppliedOrganizationAssignment> (StepAP214_PersonAndOrganizationItem::*)() const>(&StepAP214_PersonAndOrganizationItem::AppliedOrganizationAssignment),
             R"#(returns Value as a AppliedOrganizationAssignment (Null if another type))#" 
          )
        .def("AppliedSecurityClassificationAssignment",
             (handle<StepAP214_AppliedSecurityClassificationAssignment> (StepAP214_PersonAndOrganizationItem::*)() const) static_cast<handle<StepAP214_AppliedSecurityClassificationAssignment> (StepAP214_PersonAndOrganizationItem::*)() const>(&StepAP214_PersonAndOrganizationItem::AppliedSecurityClassificationAssignment),
             R"#(returns Value as a AppliedSecurityClassificationAssignment (Null if another type))#" 
          )
        .def("Approval",
             (handle<StepBasic_Approval> (StepAP214_PersonAndOrganizationItem::*)() const) static_cast<handle<StepBasic_Approval> (StepAP214_PersonAndOrganizationItem::*)() const>(&StepAP214_PersonAndOrganizationItem::Approval),
             R"#(returns Value as a Approval (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepAP214_SecurityClassificationItem from ./opencascade/StepAP214_SecurityClassificationItem.hxx
    klass = m.attr("StepAP214_SecurityClassificationItem");


    // nested enums

    static_cast<py::class_<StepAP214_SecurityClassificationItem , shared_ptr<StepAP214_SecurityClassificationItem>  , StepAP214_ApprovalItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepAP214_SecurityClassificationItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepAP214_SecurityClassificationItem::*)(  const handle<Standard_Transient> &  ) const>(&StepAP214_SecurityClassificationItem::CaseNum),
             R"#(Recognizes a SecurityClassificationItem Kind Entity that is : 1 -> Action 2 -> AssemblyComponentUsage 3 -> AssemblyComponentUsageSubstitute 4 -> ConfigurationDesign 5 -> ConfigurationEffectivity 6 -> Document 7 -> DocumentFile 8 -> DraughtingModel 9 -> GeneralProperty 10 -> MakeFromUsageOption 11 -> MaterialDesignation 12 -> MechanicalDesignGeometricPresentationRepresentation 13 -> PresentationArea 14 -> Product 15 -> ProductConcept 16 -> ProductDefinition 17 -> ProductDefinitionFormation 18 -> ProductDefinitionRelationship 19 -> ProductDefinitionUsage 20 -> PropertyDefinition 21 -> ShapeRepresentation 22 -> VersionedActionRequest 0 else)#"  , py::arg("ent")
          )
        .def("Action",
             (handle<StepBasic_Action> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepBasic_Action> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::Action),
             R"#(returns Value as a Action (Null if another type))#" 
          )
        .def("AssemblyComponentUsage",
             (handle<StepRepr_AssemblyComponentUsage> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepRepr_AssemblyComponentUsage> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::AssemblyComponentUsage),
             R"#(returns Value as a AssemblyComponentUsage (Null if another type))#" 
          )
        .def("ConfigurationDesign",
             (handle<StepRepr_ConfigurationDesign> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepRepr_ConfigurationDesign> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::ConfigurationDesign),
             R"#(returns Value as a ConfigurationDesign (Null if another type))#" 
          )
        .def("ConfigurationEffectivity",
             (handle<StepRepr_ConfigurationEffectivity> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepRepr_ConfigurationEffectivity> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::ConfigurationEffectivity),
             R"#(returns Value as a ConfigurationEffectivity (Null if another type))#" 
          )
        .def("DraughtingModel",
             (handle<StepVisual_DraughtingModel> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepVisual_DraughtingModel> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::DraughtingModel),
             R"#(returns Value as a DraughtingModel (Null if another type))#" 
          )
        .def("GeneralProperty",
             (handle<StepBasic_GeneralProperty> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepBasic_GeneralProperty> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::GeneralProperty),
             R"#(returns Value as a GeneralProperty (Null if another type))#" 
          )
        .def("MakeFromUsageOption",
             (handle<StepRepr_MakeFromUsageOption> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepRepr_MakeFromUsageOption> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::MakeFromUsageOption),
             R"#(returns Value as a MakeFromUsageOption (Null if another type))#" 
          )
        .def("ProductConcept",
             (handle<StepRepr_ProductConcept> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepRepr_ProductConcept> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::ProductConcept),
             R"#(returns Value as a ProductConcept (Null if another type))#" 
          )
        .def("ProductDefinitionUsage",
             (handle<StepRepr_ProductDefinitionUsage> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepRepr_ProductDefinitionUsage> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::ProductDefinitionUsage),
             R"#(returns Value as a ProductDefinitionUsage (Null if another type))#" 
          )
        .def("VersionedActionRequest",
             (handle<StepBasic_VersionedActionRequest> (StepAP214_SecurityClassificationItem::*)() const) static_cast<handle<StepBasic_VersionedActionRequest> (StepAP214_SecurityClassificationItem::*)() const>(&StepAP214_SecurityClassificationItem::VersionedActionRequest),
             R"#(returns Value as a VersionedActionRequest (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

// functions

// ./opencascade/StepAP214.hxx
// ./opencascade/StepAP214_AppliedApprovalAssignment.hxx
// ./opencascade/StepAP214_AppliedDateAndTimeAssignment.hxx
// ./opencascade/StepAP214_AppliedDateAssignment.hxx
// ./opencascade/StepAP214_AppliedDocumentReference.hxx
// ./opencascade/StepAP214_AppliedExternalIdentificationAssignment.hxx
// ./opencascade/StepAP214_AppliedGroupAssignment.hxx
// ./opencascade/StepAP214_AppliedOrganizationAssignment.hxx
// ./opencascade/StepAP214_AppliedPersonAndOrganizationAssignment.hxx
// ./opencascade/StepAP214_AppliedPresentedItem.hxx
// ./opencascade/StepAP214_AppliedSecurityClassificationAssignment.hxx
// ./opencascade/StepAP214_ApprovalItem.hxx
// ./opencascade/StepAP214_Array1OfApprovalItem.hxx
// ./opencascade/StepAP214_Array1OfAutoDesignDateAndPersonItem.hxx
// ./opencascade/StepAP214_Array1OfAutoDesignDateAndTimeItem.hxx
// ./opencascade/StepAP214_Array1OfAutoDesignDatedItem.hxx
// ./opencascade/StepAP214_Array1OfAutoDesignGeneralOrgItem.hxx
// ./opencascade/StepAP214_Array1OfAutoDesignGroupedItem.hxx
// ./opencascade/StepAP214_Array1OfAutoDesignPresentedItemSelect.hxx
// ./opencascade/StepAP214_Array1OfAutoDesignReferencingItem.hxx
// ./opencascade/StepAP214_Array1OfDateAndTimeItem.hxx
// ./opencascade/StepAP214_Array1OfDateItem.hxx
// ./opencascade/StepAP214_Array1OfDocumentReferenceItem.hxx
// ./opencascade/StepAP214_Array1OfExternalIdentificationItem.hxx
// ./opencascade/StepAP214_Array1OfGroupItem.hxx
// ./opencascade/StepAP214_Array1OfOrganizationItem.hxx
// ./opencascade/StepAP214_Array1OfPersonAndOrganizationItem.hxx
// ./opencascade/StepAP214_Array1OfPresentedItemSelect.hxx
// ./opencascade/StepAP214_Array1OfSecurityClassificationItem.hxx
// ./opencascade/StepAP214_AutoDesignActualDateAndTimeAssignment.hxx
// ./opencascade/StepAP214_AutoDesignActualDateAssignment.hxx
// ./opencascade/StepAP214_AutoDesignApprovalAssignment.hxx
// ./opencascade/StepAP214_AutoDesignDateAndPersonAssignment.hxx
// ./opencascade/StepAP214_AutoDesignDateAndPersonItem.hxx
// ./opencascade/StepAP214_AutoDesignDateAndTimeItem.hxx
// ./opencascade/StepAP214_AutoDesignDatedItem.hxx
// ./opencascade/StepAP214_AutoDesignDocumentReference.hxx
// ./opencascade/StepAP214_AutoDesignGeneralOrgItem.hxx
// ./opencascade/StepAP214_AutoDesignGroupAssignment.hxx
// ./opencascade/StepAP214_AutoDesignGroupedItem.hxx
// ./opencascade/StepAP214_AutoDesignNominalDateAndTimeAssignment.hxx
// ./opencascade/StepAP214_AutoDesignNominalDateAssignment.hxx
// ./opencascade/StepAP214_AutoDesignOrganizationAssignment.hxx
// ./opencascade/StepAP214_AutoDesignOrganizationItem.hxx
// ./opencascade/StepAP214_AutoDesignPersonAndOrganizationAssignment.hxx
// ./opencascade/StepAP214_AutoDesignPresentedItem.hxx
// ./opencascade/StepAP214_AutoDesignPresentedItemSelect.hxx
// ./opencascade/StepAP214_AutoDesignReferencingItem.hxx
// ./opencascade/StepAP214_AutoDesignSecurityClassificationAssignment.hxx
// ./opencascade/StepAP214_Class.hxx
// ./opencascade/StepAP214_DateAndTimeItem.hxx
// ./opencascade/StepAP214_DateItem.hxx
// ./opencascade/StepAP214_DocumentReferenceItem.hxx
// ./opencascade/StepAP214_ExternalIdentificationItem.hxx
// ./opencascade/StepAP214_ExternallyDefinedClass.hxx
// ./opencascade/StepAP214_ExternallyDefinedGeneralProperty.hxx
// ./opencascade/StepAP214_GroupItem.hxx
// ./opencascade/StepAP214_HArray1OfApprovalItem.hxx
// ./opencascade/StepAP214_HArray1OfAutoDesignDateAndPersonItem.hxx
// ./opencascade/StepAP214_HArray1OfAutoDesignDateAndTimeItem.hxx
// ./opencascade/StepAP214_HArray1OfAutoDesignDatedItem.hxx
// ./opencascade/StepAP214_HArray1OfAutoDesignGeneralOrgItem.hxx
// ./opencascade/StepAP214_HArray1OfAutoDesignGroupedItem.hxx
// ./opencascade/StepAP214_HArray1OfAutoDesignPresentedItemSelect.hxx
// ./opencascade/StepAP214_HArray1OfAutoDesignReferencingItem.hxx
// ./opencascade/StepAP214_HArray1OfDateAndTimeItem.hxx
// ./opencascade/StepAP214_HArray1OfDateItem.hxx
// ./opencascade/StepAP214_HArray1OfDocumentReferenceItem.hxx
// ./opencascade/StepAP214_HArray1OfExternalIdentificationItem.hxx
// ./opencascade/StepAP214_HArray1OfGroupItem.hxx
// ./opencascade/StepAP214_HArray1OfOrganizationItem.hxx
// ./opencascade/StepAP214_HArray1OfPersonAndOrganizationItem.hxx
// ./opencascade/StepAP214_HArray1OfPresentedItemSelect.hxx
// ./opencascade/StepAP214_HArray1OfSecurityClassificationItem.hxx
// ./opencascade/StepAP214_OrganizationItem.hxx
// ./opencascade/StepAP214_PersonAndOrganizationItem.hxx
// ./opencascade/StepAP214_PresentedItemSelect.hxx
// ./opencascade/StepAP214_Protocol.hxx
// ./opencascade/StepAP214_RepItemGroup.hxx
// ./opencascade/StepAP214_SecurityClassificationItem.hxx

// Additional functions


// operators

// register typdefs
    register_template_NCollection_Array1<StepAP214_ApprovalItem>(m,"StepAP214_Array1OfApprovalItem");
    register_template_NCollection_Array1<StepAP214_AutoDesignDateAndPersonItem>(m,"StepAP214_Array1OfAutoDesignDateAndPersonItem");
    register_template_NCollection_Array1<StepAP214_AutoDesignDateAndTimeItem>(m,"StepAP214_Array1OfAutoDesignDateAndTimeItem");
    register_template_NCollection_Array1<StepAP214_AutoDesignDatedItem>(m,"StepAP214_Array1OfAutoDesignDatedItem");
    register_template_NCollection_Array1<StepAP214_AutoDesignGeneralOrgItem>(m,"StepAP214_Array1OfAutoDesignGeneralOrgItem");
    register_template_NCollection_Array1<StepAP214_AutoDesignGroupedItem>(m,"StepAP214_Array1OfAutoDesignGroupedItem");
    register_template_NCollection_Array1<StepAP214_AutoDesignPresentedItemSelect>(m,"StepAP214_Array1OfAutoDesignPresentedItemSelect");
    register_template_NCollection_Array1<StepAP214_AutoDesignReferencingItem>(m,"StepAP214_Array1OfAutoDesignReferencingItem");
    register_template_NCollection_Array1<StepAP214_DateAndTimeItem>(m,"StepAP214_Array1OfDateAndTimeItem");
    register_template_NCollection_Array1<StepAP214_DateItem>(m,"StepAP214_Array1OfDateItem");
    register_template_NCollection_Array1<StepAP214_DocumentReferenceItem>(m,"StepAP214_Array1OfDocumentReferenceItem");
    register_template_NCollection_Array1<StepAP214_ExternalIdentificationItem>(m,"StepAP214_Array1OfExternalIdentificationItem");
    register_template_NCollection_Array1<StepAP214_GroupItem>(m,"StepAP214_Array1OfGroupItem");
    register_template_NCollection_Array1<StepAP214_OrganizationItem>(m,"StepAP214_Array1OfOrganizationItem");
    register_template_NCollection_Array1<StepAP214_PersonAndOrganizationItem>(m,"StepAP214_Array1OfPersonAndOrganizationItem");
    register_template_NCollection_Array1<StepAP214_PresentedItemSelect>(m,"StepAP214_Array1OfPresentedItemSelect");
    register_template_NCollection_Array1<StepAP214_SecurityClassificationItem>(m,"StepAP214_Array1OfSecurityClassificationItem");


// exceptions

// user-defined post-inclusion per module in the body

};

// user-defined post-inclusion per module

// user-defined post
