MagicDrawUMLInteraction

abstract def e: Interaction

implicit abstract val ops: MagicDrawUMLUtil

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def _package: Option[UMLPackage[Uml]]

def action: Set[UMLAction[MagicDrawUML]]

def actual_templateParameterSubstitution: Set[UMLTemplateParameterSubstitution[Uml]]

def allAttributes: Seq[UMLProperty[MagicDrawUML]]

def allAttributesExceptRedefined: Seq[UMLProperty[MagicDrawUML]]

def allFeatures: Set[UMLFeature[MagicDrawUML]]

def allForwardReferencesFromStereotypeTagProperties: \/[Set[Throwable], Set[UMLElement[MagicDrawUML]]]

def allForwardReferencesToElements: \/[Set[Throwable], Set[UMLElement[MagicDrawUML]]]

def allForwardReferencesToImportablePackageableElements: \/[Set[Throwable], Set[UMLPackageableElement[MagicDrawUML]]]

def allImportedPackagesTransitively: Set[UMLPackage[MagicDrawUML]]

def allNamespaces: Seq[UMLNamespace[MagicDrawUML]]

def allNamespacesWithinScope: Set[UMLNamespace[MagicDrawUML]]

def allOwnedElements: Set[UMLElement[MagicDrawUML]]

def allOwnedElementsWithinPackageScope: Set[UMLElement[MagicDrawUML]]

def allOwningPackages: Set[UMLPackage[MagicDrawUML]]

def allParents: Set[UMLClassifier[MagicDrawUML]]

def allRealizedInterfaces: Set[UMLInterface[MagicDrawUML]]

def allRoles: Set[UMLConnectableElement[MagicDrawUML]]

def allSlottableFeatures: Set[UMLStructuralFeature[MagicDrawUML]]

def allUsedInterfaces: Set[UMLInterface[MagicDrawUML]]

def allVisibleMembersAccessibleTransitively: Set[UMLPackageableElement[MagicDrawUML]]

def allVisibleMembersTransitively: Set[UMLPackageableElement[MagicDrawUML]]

def annotatedElement_comment: Set[UMLComment[Uml]]

def appendUnique[F](ss: Seq[F]*): Seq[F]

def appendUnique[F](s1: Seq[F], s2: Seq[F]): Seq[F]

def asForwardReferencesToImportableOuterPackageableElements: \/[Set[Throwable], Set[UMLPackageableElement[MagicDrawUML]]]

def asForwardReferencesToOwningElementImportableOuterPackageableElements: \/[Set[Throwable], Set[UMLPackageableElement[MagicDrawUML]]]

final def asInstanceOf[T0]: T0

def asPackageableElement: Option[UMLPackageableElement[MagicDrawUML]]

def attribute: Seq[UMLProperty[Uml]]

def behavior_behaviorExecutionSpecification: Set[UMLBehaviorExecutionSpecification[Uml]]

def behavior_callBehaviorAction: Set[UMLCallBehaviorAction[Uml]]

def behavior_compositeMetaProperties: MetaPropertyFunctions

def behavior_forwardReferencesFromMetamodelAssociations: Elements

def behavior_metaAttributes: MetaAttributeFunctions

def behavior_opaqueExpression: Set[UMLOpaqueExpression[Uml]]

def behavior_referenceMetaProperties: MetaPropertyFunctions

def behavioredClassifier(from: Option[UMLElement[MagicDrawUML]]): Option[UMLBehavioredClassifier[MagicDrawUML]]

def behavioredClassifier_compositeMetaProperties: MetaPropertyFunctions

def behavioredClassifier_forwardReferencesFromMetamodelAssociations: Elements

def behavioredClassifier_metaAttributes: MetaAttributeFunctions

def behavioredClassifier_referenceMetaProperties: MetaPropertyFunctions

def class_compositeMetaProperties: MetaPropertyFunctions

def class_forwardReferencesFromMetamodelAssociations: Elements

def class_metaAttributes: MetaAttributeFunctions

def class_referenceMetaProperties: MetaPropertyFunctions

def classifierBehavior: Option[UMLBehavior[MagicDrawUML]]

def classifierBehavior_behavioredClassifier: Option[UMLBehavioredClassifier[MagicDrawUML]]

def classifier_compositeMetaProperties: MetaPropertyFunctions

def classifier_createObjectAction: Set[UMLCreateObjectAction[Uml]]

def classifier_forwardReferencesFromMetamodelAssociations: Elements

def classifier_instanceSpecification: Set[UMLInstanceSpecification[Uml]]

def classifier_metaAttributes: MetaAttributeFunctions

def classifier_readExtentAction: Option[UMLReadExtentAction[Uml]]

def classifier_readIsClassifiedObjectAction: Set[UMLReadIsClassifiedObjectAction[Uml]]

def classifier_referenceMetaProperties: MetaPropertyFunctions

def clientDependency: Set[UMLDependency[Uml]]

def clone(): AnyRef

def collaborationUse: Set[UMLCollaborationUse[MagicDrawUML]]

def compositeMetaProperties: MetaPropertyFunctions

def conformsTo(other: Option[UMLType[MagicDrawUML]]): Boolean

def constrainedElement_constraint: Set[UMLConstraint[Uml]]

def constrainingClassifier_classifierTemplateParameter: Set[UMLClassifierTemplateParameter[Uml]]

def context: Option[UMLBehavioredClassifier[MagicDrawUML]]

def context_action: Set[UMLAction[Uml]]

def context_behavior: Set[UMLBehavior[MagicDrawUML]]

def context_diagram: Set[UMLDiagram[Uml]]

def contract_connector: Set[UMLConnector[Uml]]

def contract_substitution: Set[UMLSubstitution[Uml]]

def conveyed_conveyingFlow: Set[UMLInformationFlow[Uml]]

def covered: Iterable[UMLLifeline[Uml]]

def decisionInput_decisionNode: Set[UMLDecisionNode[Uml]]

def default_templateParameter: Set[UMLTemplateParameter[Uml]]

def deployedElement_deploymentTarget: Set[UMLDeploymentTarget[Uml]]

def directlyRealizedInterfaces: Set[UMLInterface[MagicDrawUML]]

def directlyUsedInterfaces: Set[UMLInterface[MagicDrawUML]]

def doActivity_state: Option[UMLState[Uml]]

def effect_transition: Option[UMLTransition[MagicDrawUML]]

def elementImport: Set[UMLElementImport[MagicDrawUML]]

def element_compositeMetaProperties: MetaPropertyFunctions

def element_elementValue: Set[UMLElementValue[Uml]]

def element_forwardReferencesFromMetamodelAssociations: Elements

def element_metaAttributes: MetaAttributeFunctions

def element_referenceMetaProperties: MetaPropertyFunctions

def element_xmiOrderingKey()(implicit idg: IDGenerator[MagicDrawUML]): \/[Set[Throwable], String]

def encapsulatedClassifier_compositeMetaProperties: MetaPropertyFunctions

def encapsulatedClassifier_forwardReferencesFromMetamodelAssociations: Elements

def encapsulatedClassifier_metaAttributes: MetaAttributeFunctions

def encapsulatedClassifier_referenceMetaProperties: MetaPropertyFunctions

def enclosingInteraction: Option[UMLInteraction[MagicDrawUML]]

def enclosingOperand: Option[UMLInteractionOperand[MagicDrawUML]]

def endType_association: Set[UMLAssociation[MagicDrawUML]]

def endType_associationExceptRedefinedOrDerived: Set[UMLAssociation[MagicDrawUML]]

def entry_state: Option[UMLState[Uml]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def event_durationObservation: Set[UMLDurationObservation[Uml]]

def event_timeObservation: Set[UMLTimeObservation[Uml]]

def exceptionType_exceptionHandler: Set[UMLExceptionHandler[Uml]]

def excludeCollisions(imps: Set[UMLPackageableElement[MagicDrawUML]]): Set[UMLPackageableElement[MagicDrawUML]]

def exit_state: Option[UMLState[Uml]]

UML metamodel property: derived="false" ordered="false" unique="true" aggregation="none" multiplicity="0..1" Opposite of UML metamodel property: org.omg.oti.uml.read.api.UMLState.exit

def extension: Set[UMLExtension[Uml]]

def feature: Set[UMLFeature[MagicDrawUML]]

def finalize(): Unit

def formalGate: Set[UMLGate[Uml]]

def forwardReferencesBeyondNamespaceScope()(implicit idg: IDGenerator[MagicDrawUML]): \/[Set[Throwable], Set[RelationTriple[MagicDrawUML]]]

def forwardReferencesFromMetamodelAssociations: Elements

def forwardReferencesToNamespaces()(implicit idg: IDGenerator[MagicDrawUML]): \/[Set[Throwable], Set[UMLNamespace[MagicDrawUML]]]

def forwardRelationTriples(): \/[Set[Throwable], Set[RelationTriple[MagicDrawUML]]]

def fragment: Seq[UMLInteractionFragment[Uml]]

def general: Set[UMLClassifier[MagicDrawUML]]

def generalOrdering: Set[UMLGeneralOrdering[Uml]]

def general_classifier: Set[UMLClassifier[Uml]]

def general_generalization: Set[UMLGeneralization[MagicDrawUML]]

def generalization: Set[UMLGeneralization[MagicDrawUML]]

def generatedOTI_id()(implicit idg: IDGenerator[MagicDrawUML]): \/[Set[Throwable], @@[String, OTI_ID]]

def generatedOTI_uuid()(implicit idg: IDGenerator[MagicDrawUML]): \/[Set[Throwable], @@[String, OTI_UUID]]

final def getAppliedStereotypes: \/[Set[Throwable], Map[UMLStereotype[MagicDrawUML], UMLProperty[MagicDrawUML]]]

def getAppliedStereotypesWithoutMetaclassProperties: \/[Set[Throwable], Set[UMLStereotype[Uml]]]

final def getClass(): Class[_]

def getContainingMetaPropertyEvaluator()(implicit idg: IDGenerator[MagicDrawUML]): \/[Set[Throwable], Option[MetaPropertyEvaluator]]

def getElementMetamodelPropertyValue(f: MetaPropertyEvaluator)(implicit idg: IDGenerator[MagicDrawUML]): \/[Set[Throwable], Iterable[UMLElement[MagicDrawUML]]]

def getMagicDrawBehavior: Behavior

def getMagicDrawBehavioredClassifier: BehavioredClassifier

def getMagicDrawClass: Class

def getMagicDrawClassifier: Classifier

def getMagicDrawElement: Element

def getMagicDrawEncapsulatedClassifier: EncapsulatedClassifier

def getMagicDrawInteraction: Interaction

def getMagicDrawInteractionFragment: InteractionFragment

def getMagicDrawNamedElement: NamedElement

def getMagicDrawNamespace: Namespace

def getMagicDrawPackageableElement: PackageableElement

def getMagicDrawParameterableElement: ParameterableElement

def getMagicDrawRedefinableElement: RedefinableElement

def getMagicDrawStructuredClassifier: StructuredClassifier

def getMagicDrawTemplateableElement: TemplateableElement

def getMagicDrawType: Type

def getNamesOfMember(element: Option[UMLNamedElement[MagicDrawUML]]): Set[String]

final def getPackageOwnerWithEffectiveURI()(implicit otiCharacteristicsProvider: OTICharacteristicsProvider[MagicDrawUML]): \/[Set[Throwable], Option[UMLPackage[MagicDrawUML]]]

def getStereotypeTagPropertyBooleanValues(tagProperty: UMLProperty[MagicDrawUML]): \/[Set[Throwable], Iterable[Boolean]]

def getStereotypeTagPropertyEnumValues(tagProperty: UMLProperty[MagicDrawUML]): \/[Set[Throwable], Iterable[UMLEnumerationLiteral[MagicDrawUML]]]

def getStereotypeTagPropertyInstanceValues(tagProperty: UMLProperty[MagicDrawUML]): \/[Set[Throwable], Iterable[UMLInstanceSpecification[MagicDrawUML]]]

def getStereotypeTagPropertyIntegerValues(tagProperty: UMLProperty[MagicDrawUML]): \/[Set[Throwable], Iterable[Int]]

def getStereotypeTagPropertyRealValues(tagProperty: UMLProperty[MagicDrawUML]): \/[Set[Throwable], Iterable[Double]]

def getStereotypeTagPropertyStringValues(tagProperty: UMLProperty[MagicDrawUML]): \/[Set[Throwable], Iterable[String]]

def getStereotypeTagPropertyUnlimitedNaturalValues(tagProperty: UMLProperty[MagicDrawUML]): \/[Set[Throwable], Iterable[Int]]

def hasStereotype(s: UMLStereotype[Uml]): \/[Set[Throwable], Boolean]

def hasVisibilityOf(n: Option[UMLNamedElement[MagicDrawUML]]): Boolean

def hashCode(): Int

val id_metaDocumentAttributeFunction: MetaDocumentAttributeStringFunction[MagicDrawUML, UMLElement[MagicDrawUML]]

def importMembers(imps: Set[UMLPackageableElement[MagicDrawUML]]): Set[UMLPackageableElement[MagicDrawUML]]

def importedElement_import: Set[UMLElementImport[MagicDrawUML]]

def importedMember: Set[UMLPackageableElement[MagicDrawUML]]

def importedMember_namespace: Set[UMLNamespace[Uml]]

def importedPackages: Set[UMLPackage[MagicDrawUML]]

def informationSource_informationFlow: Set[UMLInformationFlow[MagicDrawUML]]

def informationTarget_informationFlow: Set[UMLInformationFlow[MagicDrawUML]]

def inherit(inhs: Set[UMLNamedElement[MagicDrawUML]]): Set[UMLNamedElement[MagicDrawUML]]

def inheritableMembers(c: Option[UMLClassifier[MagicDrawUML]]): Set[UMLNamedElement[MagicDrawUML]]

def inheritedMember: Set[UMLNamedElement[MagicDrawUML]]

def inheritedMember_inheritingClassifier: Set[UMLClassifier[Uml]]

def inputParameters: Seq[UMLParameter[MagicDrawUML]]

def interactionFragment_compositeMetaProperties: MetaPropertyFunctions

def interactionFragment_forwardReferencesFromMetamodelAssociations: Elements

def interactionFragment_metaAttributes: MetaAttributeFunctions

def interactionFragment_referenceMetaProperties: MetaPropertyFunctions

def interaction_compositeMetaProperties: MetaPropertyFunctions

def interaction_forwardReferencesFromMetamodelAssociations: Elements

def interaction_metaAttributes: MetaAttributeFunctions

def interaction_referenceMetaProperties: MetaPropertyFunctions

def interfaceRealization: Set[UMLInterfaceRealization[MagicDrawUML]]

def isAbstract: Boolean

def isActive: Boolean

def isAncestorOf(other: UMLElement[Uml]): \/[Set[Throwable], Boolean]

def isCompatibleWith(p: Option[UMLParameterableElement[MagicDrawUML]]): Boolean

def isConsistentWith(redefiningElement: Option[UMLRedefinableElement[MagicDrawUML]]): Boolean

def isDistinguishableFrom(n: Option[UMLNamedElement[MagicDrawUML]], ns: Option[UMLNamespace[MagicDrawUML]]): Boolean

def isFinalSpecialization: Boolean

final def isInstanceOf[T0]: Boolean

def isLeaf: Boolean

def isRedefinitionContextValid(redefinedElement: Option[UMLRedefinableElement[MagicDrawUML]]): Boolean

def isReentrant: Boolean

def isSubstitutableFor(contract: Option[UMLClassifier[MagicDrawUML]]): Boolean

def isTemplate: Boolean

def isTemplateParameter: Boolean

def lifeline: Set[UMLLifeline[MagicDrawUML]]

def lookupTagValueByProperty(tagProperty: UMLProperty[MagicDrawUML]): \/[Set[Throwable], Option[UMLStereotypeTagValue[MagicDrawUML]]]

def makesVisible(el: Option[UMLNamedElement[MagicDrawUML]]): Boolean

def maySpecializeType(c: Option[UMLClassifier[MagicDrawUML]]): Boolean

def member: Set[UMLNamedElement[Uml]]

def member_memberNamespace: Set[UMLNamespace[Uml]]

def membersAreDistinguishable: Boolean

def message: Set[UMLMessage[MagicDrawUML]]

def message_considerIgnoreFragment: Set[UMLConsiderIgnoreFragment[Uml]]

def metaAttributes: MetaAttributeFunctions

def metaclass_name: String

def mofMetaclassName: String

def mofXMI_metaAtttributes: MetaAttributeFunctions

def mustBeOwned: Boolean

def name: Option[String]

def nameExpression: Option[UMLStringExpression[MagicDrawUML]]

def namedElement_compositeMetaProperties: MetaPropertyFunctions

def namedElement_forwardReferencesFromMetamodelAssociations: Elements

def namedElement_metaAttributes: MetaAttributeFunctions

def namedElement_referenceMetaProperties: MetaPropertyFunctions

def namespace: Option[UMLNamespace[MagicDrawUML]]

def namespace_compositeMetaProperties: MetaPropertyFunctions

def namespace_forwardReferencesFromMetamodelAssociations: Elements

def namespace_metaAttributes: MetaAttributeFunctions

def namespace_referenceMetaProperties: MetaPropertyFunctions

final def ne(arg0: AnyRef): Boolean

def nestedClassifier: Seq[UMLClassifier[Uml]]

def nestedClassifier_interface: Option[UMLInterface[MagicDrawUML]]

def nestedClassifier_nestingClass: Option[UMLClass[MagicDrawUML]]

def newClassifier_reclassifyObjectAction: Set[UMLReclassifyObjectAction[Uml]]

final def notify(): Unit

final def notifyAll(): Unit

def oldClassifier_reclassifyObjectAction: Set[UMLReclassifyObjectAction[Uml]]

def oti_xmiID()(implicit otiCharacteristicsProvider: OTICharacteristicsProvider[MagicDrawUML]): \/[Set[Throwable], Option[@@[String, OTI_ID]]]

def oti_xmiUUID()(implicit otiCharacteristicsProvider: OTICharacteristicsProvider[MagicDrawUML]): \/[Set[Throwable], Option[@@[String, OTI_UUID]]]

def outputParameters: Seq[UMLParameter[MagicDrawUML]]

def ownedActual_owningTemplateParameterSubstitution: Option[UMLTemplateParameterSubstitution[MagicDrawUML]]

def ownedAttribute: Seq[UMLProperty[Uml]]

def ownedBehavior: Set[UMLBehavior[MagicDrawUML]]

def ownedBehavior_behavioredClassifier: Option[UMLBehavioredClassifier[Uml]]

def ownedComment: Set[UMLComment[MagicDrawUML]]

def ownedConnector: Set[UMLConnector[MagicDrawUML]]

def ownedDefault_templateParameter: Option[UMLTemplateParameter[MagicDrawUML]]

def ownedDiagram: Set[UMLDiagram[MagicDrawUML]]

def ownedElement: Set[UMLElement[Uml]]

def ownedMember: Set[UMLNamedElement[Uml]]

def ownedOperation: Seq[UMLOperation[Uml]]

def ownedParameter: Seq[UMLParameter[Uml]]

def ownedParameterSet: Set[UMLParameterSet[MagicDrawUML]]

def ownedPort: Set[UMLPort[MagicDrawUML]]

def ownedReception: Set[UMLReception[MagicDrawUML]]

def ownedRule: Set[UMLConstraint[MagicDrawUML]]

def ownedTemplateSignature: Option[UMLRedefinableTemplateSignature[MagicDrawUML]]

def ownedUseCase: Set[UMLUseCase[MagicDrawUML]]

def owner: Option[UMLElement[Uml]]

final def owningNamespace: Option[UMLNamespace[MagicDrawUML]]

def owningPackage: Option[UMLPackage[MagicDrawUML]]

final def owningPackages: Set[UMLPackage[MagicDrawUML]]

def owningTemplateParameter: Option[UMLTemplateParameter[Uml]]

def packageImport: Set[UMLPackageImport[MagicDrawUML]]

def packageableElement_compositeMetaProperties: MetaPropertyFunctions

def packageableElement_forwardReferencesFromMetamodelAssociations: Elements

def packageableElement_metaAttributes: MetaAttributeFunctions

def packageableElement_referenceMetaProperties: MetaPropertyFunctions

def packagedElement_component: Option[UMLComponent[MagicDrawUML]]

def packagedElement_owningPackage: Option[UMLPackage[MagicDrawUML]]

def parameterableElement_compositeMetaProperties: MetaPropertyFunctions

def parameterableElement_forwardReferencesFromMetamodelAssociations: Elements

def parameterableElement_metaAttributes: MetaAttributeFunctions

def parameterableElement_referenceMetaProperties: MetaPropertyFunctions

def parameterableElements: Set[UMLParameterableElement[MagicDrawUML]]

def parents: Set[UMLClassifier[MagicDrawUML]]

def part: Set[UMLProperty[MagicDrawUML]]

def postcondition: Set[UMLConstraint[Uml]]

def powertypeExtent: Set[UMLGeneralizationSet[Uml]]

def precondition: Set[UMLConstraint[Uml]]

def qualifiedName: Option[String]

def raisedException_behavioralFeature: Set[UMLBehavioralFeature[Uml]]

def raisedException_operation: Set[UMLOperation[MagicDrawUML]]

def realizingClassifier_componentRealization: Set[UMLComponentRealization[Uml]]

def redefinableElement_compositeMetaProperties: MetaPropertyFunctions

def redefinableElement_forwardReferencesFromMetamodelAssociations: Elements

def redefinableElement_metaAttributes: MetaAttributeFunctions

def redefinableElement_referenceMetaProperties: MetaPropertyFunctions

def redefinedBehavior: Set[UMLBehavior[Uml]]

def redefinedBehavior_behavior: Set[UMLBehavior[Uml]]

def redefinedClassifier: Set[UMLClassifier[MagicDrawUML]]

def redefinedClassifier_classifier: Set[UMLClassifier[MagicDrawUML]]

def redefinedElement: Set[UMLRedefinableElement[Uml]]

def redefinedElement_redefinableElement: Set[UMLRedefinableElement[Uml]]

def redefinitionContext: Iterable[UMLClassifier[Uml]]

def redefinitionContext_redefinableElement: Set[UMLRedefinableElement[Uml]]

def redefinitionContext_region: Set[UMLRegion[MagicDrawUML]]

def redefinitionContext_state: Set[UMLState[MagicDrawUML]]

def redefinitionContext_transition: Set[UMLTransition[MagicDrawUML]]

def reducer_reduceAction: Set[UMLReduceAction[Uml]]

def referenceMetaProperties: MetaPropertyFunctions

def refersTo_interactionUse: Set[UMLInteractionUse[Uml]]

def relatedElement_relationship: Set[UMLRelationship[Uml]]

def representation: Option[UMLCollaborationUse[MagicDrawUML]]

def represented_representation: Set[UMLInformationItem[Uml]]

def represents_activityPartition: Set[UMLActivityPartition[Uml]]

def role: Set[UMLConnectableElement[Uml]]

def selectInContainmentTreeRunnable: Runnable

def selection_objectFlow: Set[UMLObjectFlow[Uml]]

def selection_objectNode: Set[UMLObjectNode[Uml]]

def separator: Option[String]

def setName(name: String): Unit

def signature_message: Set[UMLMessage[Uml]]

def source_directedRelationship: Set[UMLDirectedRelationship[Uml]]

def specification: Option[UMLBehavioralFeature[Uml]]

def structuredClassifier_compositeMetaProperties: MetaPropertyFunctions

def structuredClassifier_forwardReferencesFromMetamodelAssociations: Elements

def structuredClassifier_metaAttributes: MetaAttributeFunctions

def structuredClassifier_referenceMetaProperties: MetaPropertyFunctions

def substitution: Set[UMLSubstitution[MagicDrawUML]]

def superClass: Set[UMLClass[MagicDrawUML]]

def superClass_class: Set[UMLClass[MagicDrawUML]]

def supplier_supplierDependency: Set[UMLDependency[MagicDrawUML]]

final def synchronized[T0](arg0: ⇒ T0): T0

def tagValues: \/[Set[Throwable], Seq[MagicDrawUMLStereotypeTagValue]]

def target_directedRelationship: Set[UMLDirectedRelationship[Uml]]

def templateBinding: Set[UMLTemplateBinding[Uml]]

def templateParameter: Option[UMLClassifierTemplateParameter[Uml]]

def templateableElement_compositeMetaProperties: MetaPropertyFunctions

def templateableElement_forwardReferencesFromMetamodelAssociations: Elements

def templateableElement_metaAttributes: MetaAttributeFunctions

def templateableElement_referenceMetaProperties: MetaPropertyFunctions

def toString(): String

def toWrappedObjectString: String

def toolSpecific_id: @@[String, TOOL_SPECIFIC_ID]

def toolSpecific_url: @@[String, TOOL_SPECIFIC_URL]

def toolSpecific_uuid: Option[@@[String, TOOL_SPECIFIC_UUID]]

def transformation_objectFlow: Set[UMLObjectFlow[Uml]]

def type_compositeMetaProperties: MetaPropertyFunctions

def type_forwardReferencesFromMetamodelAssociations: Elements

val type_metaAttributeFunction: MetaAttributeStringFunction[MagicDrawUML, UMLElement[MagicDrawUML]]

def type_metaAttributes: MetaAttributeFunctions

def type_operation: Set[UMLOperation[Uml]]

def type_referenceMetaProperties: MetaPropertyFunctions

def type_typedElement: Set[UMLTypedElement[Uml]]

implicit val umlOps: MagicDrawUMLUtil

def unmarshallType_unmarshallAction: Set[UMLUnmarshallAction[Uml]]

def useCase: Set[UMLUseCase[Uml]]

def utilizedElement_manifestation: Set[UMLManifestation[Uml]]

val uuid_metaDocumentAttributeFunction: MetaDocumentAttributeStringFunction[MagicDrawUML, UMLElement[MagicDrawUML]]

def validate_cannot_import_ownedMembers: Boolean

def validate_cannot_import_self: Boolean

def validate_class_behavior: Boolean

def validate_feature_of_context_classifier: Boolean

def validate_has_no_qualified_name: Boolean

def validate_has_owner: Boolean

def validate_has_qualified_name: Boolean

def validate_maps_to_generalization_set: Boolean

def validate_members_distinguishable: Boolean

def validate_most_one_behavior: Boolean

def validate_namespace_needs_visibility: Boolean

def validate_no_cycles_in_generalization: Boolean

def validate_non_final_parents: Boolean

def validate_non_leaf_redefinition: Boolean

def validate_not_contained: Boolean

def validate_not_own_self: Boolean

def validate_parameters_match: Boolean

def validate_passive_class: Boolean

def validate_redefinition_consistent: Boolean

def validate_redefinition_context_valid: Boolean

def validate_specialize_type: Boolean

def validate_visibility_needs_ownership: Boolean

def visibility: Option[uml.read.api.UMLVisibilityKind.Value]

def visibleMembers: Set[UMLPackageableElement[MagicDrawUML]]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def xmiElementLabel: String

def xmiID()(implicit idg: IDGenerator[MagicDrawUML]): \/[Set[Throwable], @@[String, OTI_ID]]

def xmiOrderingKey()(implicit idg: IDGenerator[MagicDrawUML]): \/[Set[Throwable], String]