diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/UMLXPackage.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/UMLXPackage.java
index 4c887f6..dad731d 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/UMLXPackage.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/UMLXPackage.java
@@ -72,1340 +72,6 @@
 	UMLXPackage eINSTANCE = org.eclipse.qvtd.umlx.impl.UMLXPackageImpl.init();
 
 	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.UMLXElementImpl <em>Element</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXElementImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getUMLXElement()
-	 * @generated
-	 */
-	int UMLX_ELEMENT = 16;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_ELEMENT__COMMENTS = 0;
-
-	/**
-	 * The number of structural features of the '<em>Element</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_ELEMENT_FEATURE_COUNT = 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.UMLXNamedElementImpl <em>Named Element</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXNamedElementImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getUMLXNamedElement()
-	 * @generated
-	 */
-	int UMLX_NAMED_ELEMENT = 18;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.RelDiagramImpl <em>Rel Diagram</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.RelDiagramImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getRelDiagram()
-	 * @generated
-	 */
-	int REL_DIAGRAM = 0;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.RelDomainNodeImpl <em>Rel Domain Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.RelDomainNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getRelDomainNode()
-	 * @generated
-	 */
-	int REL_DOMAIN_NODE = 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.RelEdgeImpl <em>Rel Edge</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.RelEdgeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getRelEdge()
-	 * @generated
-	 */
-	int REL_EDGE = 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.RelInvocationEdgeImpl <em>Rel Invocation Edge</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.RelInvocationEdgeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getRelInvocationEdge()
-	 * @generated
-	 */
-	int REL_INVOCATION_EDGE = 3;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.RelInvocationNodeImpl <em>Rel Invocation Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.RelInvocationNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getRelInvocationNode()
-	 * @generated
-	 */
-	int REL_INVOCATION_NODE = 4;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.RelPatternEdgeImpl <em>Rel Pattern Edge</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.RelPatternEdgeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getRelPatternEdge()
-	 * @generated
-	 */
-	int REL_PATTERN_EDGE = 6;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.TxDiagramImpl <em>Tx Diagram</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.TxDiagramImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getTxDiagram()
-	 * @generated
-	 */
-	int TX_DIAGRAM = 8;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.TxNodeImpl <em>Tx Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.TxNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getTxNode()
-	 * @generated
-	 */
-	int TX_NODE = 10;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.TxKeyNodeImpl <em>Tx Key Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.TxKeyNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getTxKeyNode()
-	 * @generated
-	 */
-	int TX_KEY_NODE = 9;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.TxPartNodeImpl <em>Tx Part Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.TxPartNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getTxPartNode()
-	 * @generated
-	 */
-	int TX_PART_NODE = 13;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.TxPackageNodeImpl <em>Tx Package Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.TxPackageNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getTxPackageNode()
-	 * @generated
-	 */
-	int TX_PACKAGE_NODE = 11;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.TxTypedModelNodeImpl <em>Tx Typed Model Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.TxTypedModelNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getTxTypedModelNode()
-	 * @generated
-	 */
-	int TX_TYPED_MODEL_NODE = 15;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.UMLXModelImpl <em>Model</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXModelImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getUMLXModel()
-	 * @generated
-	 */
-	int UMLX_MODEL = 17;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_NAMED_ELEMENT__COMMENTS = UMLX_ELEMENT__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_NAMED_ELEMENT__NAME = UMLX_ELEMENT_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the '<em>Named Element</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_NAMED_ELEMENT_FEATURE_COUNT = UMLX_ELEMENT_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DIAGRAM__COMMENTS = UMLX_NAMED_ELEMENT__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DIAGRAM__NAME = UMLX_NAMED_ELEMENT__NAME;
-
-	/**
-	 * The feature id for the '<em><b>Is Abstract</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DIAGRAM__IS_ABSTRACT = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Is Top</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DIAGRAM__IS_TOP = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Owned Rel Domain Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DIAGRAM__OWNED_REL_DOMAIN_NODES = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Owned Rel Invocation Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DIAGRAM__OWNED_REL_INVOCATION_NODES = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Owning Tx Diagram</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DIAGRAM__OWNING_TX_DIAGRAM = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4;
-
-	/**
-	 * The number of structural features of the '<em>Rel Diagram</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DIAGRAM_FEATURE_COUNT = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.RelNodeImpl <em>Rel Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.RelNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getRelNode()
-	 * @generated
-	 */
-	int REL_NODE = 5;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_NODE__COMMENTS = UMLX_ELEMENT__COMMENTS;
-
-	/**
-	 * The number of structural features of the '<em>Rel Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_NODE_FEATURE_COUNT = UMLX_ELEMENT_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DOMAIN_NODE__COMMENTS = REL_NODE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Is Enforced</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DOMAIN_NODE__IS_ENFORCED = REL_NODE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Owned Rel Pattern Edges</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES = REL_NODE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Owned Rel Pattern Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES = REL_NODE_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Owning Rel Diagram</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DOMAIN_NODE__OWNING_REL_DIAGRAM = REL_NODE_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Referred Tx Typed Model Node</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DOMAIN_NODE__REFERRED_TX_TYPED_MODEL_NODE = REL_NODE_FEATURE_COUNT + 4;
-
-	/**
-	 * The number of structural features of the '<em>Rel Domain Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_DOMAIN_NODE_FEATURE_COUNT = REL_NODE_FEATURE_COUNT + 5;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_EDGE__COMMENTS = UMLX_ELEMENT__COMMENTS;
-
-	/**
-	 * The number of structural features of the '<em>Rel Edge</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_EDGE_FEATURE_COUNT = UMLX_ELEMENT_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_EDGE__COMMENTS = REL_EDGE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Invoking Rel Pattern Node</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE = REL_EDGE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Owning Rel Invocation Node</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE = REL_EDGE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Referred Rel Pattern Node</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_EDGE__REFERRED_REL_PATTERN_NODE = REL_EDGE_FEATURE_COUNT + 2;
-
-	/**
-	 * The number of structural features of the '<em>Rel Invocation Edge</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_EDGE_FEATURE_COUNT = REL_EDGE_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_NODE__COMMENTS = REL_NODE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Is Then</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_NODE__IS_THEN = REL_NODE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Owning Rel Diagram</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_NODE__OWNING_REL_DIAGRAM = REL_NODE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Owned Rel Invocation Edges</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES = REL_NODE_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Referred Rel Diagram</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_NODE__REFERRED_REL_DIAGRAM = REL_NODE_FEATURE_COUNT + 3;
-
-	/**
-	 * The number of structural features of the '<em>Rel Invocation Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_INVOCATION_NODE_FEATURE_COUNT = REL_NODE_FEATURE_COUNT + 4;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.RelPatternNodeImpl <em>Rel Pattern Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.RelPatternNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getRelPatternNode()
-	 * @generated
-	 */
-	int REL_PATTERN_NODE = 7;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_EDGE__COMMENTS = REL_EDGE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Owning Rel Domain Node</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE = REL_EDGE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Referred EStructural Feature</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_EDGE__REFERRED_ESTRUCTURAL_FEATURE = REL_EDGE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Source</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_EDGE__SOURCE = REL_EDGE_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Source Index</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_EDGE__SOURCE_INDEX = REL_EDGE_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Target</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_EDGE__TARGET = REL_EDGE_FEATURE_COUNT + 4;
-
-	/**
-	 * The number of structural features of the '<em>Rel Pattern Edge</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_EDGE_FEATURE_COUNT = REL_EDGE_FEATURE_COUNT + 5;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__COMMENTS = REL_NODE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__NAME = REL_NODE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Is Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__IS_MANY = REL_NODE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Is Null Free</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__IS_NULL_FREE = REL_NODE_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Is Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__IS_ORDERED = REL_NODE_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Is Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__IS_REQUIRED = REL_NODE_FEATURE_COUNT + 4;
-
-	/**
-	 * The feature id for the '<em><b>Is Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__IS_UNIQUE = REL_NODE_FEATURE_COUNT + 5;
-
-	/**
-	 * The feature id for the '<em><b>Referred EClassifier</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__REFERRED_ECLASSIFIER = REL_NODE_FEATURE_COUNT + 6;
-
-	/**
-	 * The feature id for the '<em><b>Incoming</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__INCOMING = REL_NODE_FEATURE_COUNT + 7;
-
-	/**
-	 * The feature id for the '<em><b>Init Expression Lines</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__INIT_EXPRESSION_LINES = REL_NODE_FEATURE_COUNT + 8;
-
-	/**
-	 * The feature id for the '<em><b>Invoking Rel Invocation Edges</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES = REL_NODE_FEATURE_COUNT + 9;
-
-	/**
-	 * The feature id for the '<em><b>Is Anon</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__IS_ANON = REL_NODE_FEATURE_COUNT + 10;
-
-	/**
-	 * The feature id for the '<em><b>Is Root</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__IS_ROOT = REL_NODE_FEATURE_COUNT + 11;
-
-	/**
-	 * The feature id for the '<em><b>Outgoing</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__OUTGOING = REL_NODE_FEATURE_COUNT + 12;
-
-	/**
-	 * The feature id for the '<em><b>Owning Rel Domain Node</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE = REL_NODE_FEATURE_COUNT + 13;
-
-	/**
-	 * The number of structural features of the '<em>Rel Pattern Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REL_PATTERN_NODE_FEATURE_COUNT = REL_NODE_FEATURE_COUNT + 14;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_DIAGRAM__COMMENTS = UMLX_NAMED_ELEMENT__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_DIAGRAM__NAME = UMLX_NAMED_ELEMENT__NAME;
-
-	/**
-	 * The feature id for the '<em><b>Owned Rel Diagrams</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_DIAGRAM__OWNED_REL_DIAGRAMS = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Owned Tx Key Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_DIAGRAM__OWNED_TX_KEY_NODES = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Owned Tx Package Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_DIAGRAM__OWNED_TX_PACKAGE_NODES = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Owned Tx Query Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_DIAGRAM__OWNED_TX_QUERY_NODES = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Owned Tx Typed Model Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4;
-
-	/**
-	 * The feature id for the '<em><b>Package</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_DIAGRAM__PACKAGE = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5;
-
-	/**
-	 * The number of structural features of the '<em>Tx Diagram</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_DIAGRAM_FEATURE_COUNT = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 6;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_NODE__COMMENTS = UMLX_ELEMENT__COMMENTS;
-
-	/**
-	 * The number of structural features of the '<em>Tx Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_NODE_FEATURE_COUNT = UMLX_ELEMENT_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_KEY_NODE__COMMENTS = TX_NODE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Owned Tx Part Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_KEY_NODE__OWNED_TX_PART_NODES = TX_NODE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Owning Tx Diagram</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_KEY_NODE__OWNING_TX_DIAGRAM = TX_NODE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Referred EClass</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_KEY_NODE__REFERRED_ECLASS = TX_NODE_FEATURE_COUNT + 2;
-
-	/**
-	 * The number of structural features of the '<em>Tx Key Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_KEY_NODE_FEATURE_COUNT = TX_NODE_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PACKAGE_NODE__COMMENTS = TX_NODE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Import Aliases</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PACKAGE_NODE__IMPORT_ALIASES = TX_NODE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Owning Tx Diagram</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PACKAGE_NODE__OWNING_TX_DIAGRAM = TX_NODE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Referred EPackage</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PACKAGE_NODE__REFERRED_EPACKAGE = TX_NODE_FEATURE_COUNT + 2;
-
-	/**
-	 * The number of structural features of the '<em>Tx Package Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PACKAGE_NODE_FEATURE_COUNT = TX_NODE_FEATURE_COUNT + 3;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.TxParameterNodeImpl <em>Tx Parameter Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.TxParameterNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getTxParameterNode()
-	 * @generated
-	 */
-	int TX_PARAMETER_NODE = 12;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE__COMMENTS = TX_NODE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE__NAME = TX_NODE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Is Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE__IS_MANY = TX_NODE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Is Null Free</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE__IS_NULL_FREE = TX_NODE_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Is Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE__IS_ORDERED = TX_NODE_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Is Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE__IS_REQUIRED = TX_NODE_FEATURE_COUNT + 4;
-
-	/**
-	 * The feature id for the '<em><b>Is Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE__IS_UNIQUE = TX_NODE_FEATURE_COUNT + 5;
-
-	/**
-	 * The feature id for the '<em><b>Referred EClassifier</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE__REFERRED_ECLASSIFIER = TX_NODE_FEATURE_COUNT + 6;
-
-	/**
-	 * The feature id for the '<em><b>Owning Tx Query Node</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE = TX_NODE_FEATURE_COUNT + 7;
-
-	/**
-	 * The number of structural features of the '<em>Tx Parameter Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PARAMETER_NODE_FEATURE_COUNT = TX_NODE_FEATURE_COUNT + 8;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PART_NODE__COMMENTS = TX_NODE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Owning Tx Key Node</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PART_NODE__OWNING_TX_KEY_NODE = TX_NODE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Is Opposite</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PART_NODE__IS_OPPOSITE = TX_NODE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Referred EStructural Feature</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PART_NODE__REFERRED_ESTRUCTURAL_FEATURE = TX_NODE_FEATURE_COUNT + 2;
-
-	/**
-	 * The number of structural features of the '<em>Tx Part Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_PART_NODE_FEATURE_COUNT = TX_NODE_FEATURE_COUNT + 3;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.TxQueryNodeImpl <em>Tx Query Node</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.TxQueryNodeImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getTxQueryNode()
-	 * @generated
-	 */
-	int TX_QUERY_NODE = 14;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__COMMENTS = TX_NODE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__NAME = TX_NODE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Is Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__IS_MANY = TX_NODE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Is Null Free</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__IS_NULL_FREE = TX_NODE_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Is Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__IS_ORDERED = TX_NODE_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Is Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__IS_REQUIRED = TX_NODE_FEATURE_COUNT + 4;
-
-	/**
-	 * The feature id for the '<em><b>Is Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__IS_UNIQUE = TX_NODE_FEATURE_COUNT + 5;
-
-	/**
-	 * The feature id for the '<em><b>Referred EClassifier</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__REFERRED_ECLASSIFIER = TX_NODE_FEATURE_COUNT + 6;
-
-	/**
-	 * The feature id for the '<em><b>Init Expression Lines</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__INIT_EXPRESSION_LINES = TX_NODE_FEATURE_COUNT + 7;
-
-	/**
-	 * The feature id for the '<em><b>Owned Tx Parameter Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES = TX_NODE_FEATURE_COUNT + 8;
-
-	/**
-	 * The feature id for the '<em><b>Owning Tx Diagram</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE__OWNING_TX_DIAGRAM = TX_NODE_FEATURE_COUNT + 9;
-
-	/**
-	 * The number of structural features of the '<em>Tx Query Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_QUERY_NODE_FEATURE_COUNT = TX_NODE_FEATURE_COUNT + 10;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_TYPED_MODEL_NODE__COMMENTS = TX_NODE__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_TYPED_MODEL_NODE__NAME = TX_NODE_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Check</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_TYPED_MODEL_NODE__CHECK = TX_NODE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Depends Ons</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_TYPED_MODEL_NODE__DEPENDS_ONS = TX_NODE_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Enforce</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_TYPED_MODEL_NODE__ENFORCE = TX_NODE_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Owning Tx Diagram</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM = TX_NODE_FEATURE_COUNT + 4;
-
-	/**
-	 * The feature id for the '<em><b>Used Tx Package Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_TYPED_MODEL_NODE__USED_TX_PACKAGE_NODES = TX_NODE_FEATURE_COUNT + 5;
-
-	/**
-	 * The number of structural features of the '<em>Tx Typed Model Node</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TX_TYPED_MODEL_NODE_FEATURE_COUNT = TX_NODE_FEATURE_COUNT + 6;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_MODEL__COMMENTS = UMLX_ELEMENT__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Owned Tx Diagrams</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_MODEL__OWNED_TX_DIAGRAMS = UMLX_ELEMENT_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the '<em>Model</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_MODEL_FEATURE_COUNT = UMLX_ELEMENT_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.qvtd.umlx.impl.UMLXTypedElementImpl <em>Typed Element</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXTypedElementImpl
-	 * @see org.eclipse.qvtd.umlx.impl.UMLXPackageImpl#getUMLXTypedElement()
-	 * @generated
-	 */
-	int UMLX_TYPED_ELEMENT = 19;
-
-	/**
-	 * The feature id for the '<em><b>Comments</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_TYPED_ELEMENT__COMMENTS = UMLX_NAMED_ELEMENT__COMMENTS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_TYPED_ELEMENT__NAME = UMLX_NAMED_ELEMENT__NAME;
-
-	/**
-	 * The feature id for the '<em><b>Is Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_TYPED_ELEMENT__IS_MANY = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Is Null Free</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_TYPED_ELEMENT__IS_NULL_FREE = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Is Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_TYPED_ELEMENT__IS_ORDERED = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Is Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_TYPED_ELEMENT__IS_REQUIRED = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Is Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_TYPED_ELEMENT__IS_UNIQUE = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4;
-
-	/**
-	 * The feature id for the '<em><b>Referred EClassifier</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5;
-
-	/**
-	 * The number of structural features of the '<em>Typed Element</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UMLX_TYPED_ELEMENT_FEATURE_COUNT = UMLX_NAMED_ELEMENT_FEATURE_COUNT + 6;
-
-	/**
 	 * Returns the meta object for class '{@link org.eclipse.qvtd.umlx.RelDiagram <em>Rel Diagram</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/UMLXTables.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/UMLXTables.java
index 9433f96..a90cfd5 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/UMLXTables.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/UMLXTables.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2016, 2018 Willink Transformations and others.
+ * Copyright (c) 2016, 2019 Willink Transformations and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
@@ -19,8 +19,19 @@
  *******************************************************************************/
 package org.eclipse.qvtd.umlx;
 
+import java.lang.String;
+import org.eclipse.emf.ecore.EcorePackage;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.ocl.pivot.TemplateParameters;
+import org.eclipse.ocl.pivot.ids.ClassId;
+import org.eclipse.ocl.pivot.ids.CollectionTypeId;
+import org.eclipse.ocl.pivot.ids.DataTypeId;
+import org.eclipse.ocl.pivot.ids.IdManager;
+import org.eclipse.ocl.pivot.ids.NsURIPackageId;
+import org.eclipse.ocl.pivot.ids.RootPackageId;
+import org.eclipse.ocl.pivot.ids.TuplePartId;
+import org.eclipse.ocl.pivot.ids.TupleTypeId;
+import org.eclipse.ocl.pivot.ids.TypeId;
 import org.eclipse.ocl.pivot.internal.library.ecore.EcoreExecutorPackage;
 import org.eclipse.ocl.pivot.internal.library.ecore.EcoreExecutorProperty;
 import org.eclipse.ocl.pivot.internal.library.ecore.EcoreExecutorType;
@@ -33,6 +44,9 @@
 import org.eclipse.ocl.pivot.internal.library.executor.ExecutorType;
 import org.eclipse.ocl.pivot.oclstdlib.OCLstdlibTables;
 import org.eclipse.ocl.pivot.utilities.TypeUtil;
+import org.eclipse.ocl.pivot.utilities.ValueUtil;
+import org.eclipse.ocl.pivot.values.IntegerValue;
+import org.eclipse.qvtd.umlx.UMLXPackage;
 import org.eclipse.qvtd.umlx.UMLXTables;
 
 /**
@@ -60,98 +74,98 @@
 	/**
 	 *	Constants used by auto-generated code.
 	 */
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull RootPackageId PACKid_$metamodel$ = org.eclipse.ocl.pivot.ids.IdManager.getRootPackageId("$metamodel$");
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull NsURIPackageId PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore = org.eclipse.ocl.pivot.ids.IdManager.getNsURIPackageId("http://www.eclipse.org/emf/2002/Ecore", null, org.eclipse.emf.ecore.EcorePackage.eINSTANCE);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull NsURIPackageId PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX = org.eclipse.ocl.pivot.ids.IdManager.getNsURIPackageId("http://www.eclipse.org/qvt/2016/UMLX", null, org.eclipse.qvtd.umlx.UMLXPackage.eINSTANCE);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_Class = org.eclipse.qvtd.umlx.UMLXTables.PACKid_$metamodel$.getClassId("Class", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_EAttribute = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EAttribute", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_EClass = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EClass", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_EClassifier = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EClassifier", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_EPackage = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EPackage", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_EReference = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EReference", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_EStructuralFeature = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EStructuralFeature", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_RelDiagram = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelDiagram", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_RelDomainNode = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelDomainNode", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_RelInvocationEdge = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelInvocationEdge", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_RelInvocationNode = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelInvocationNode", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_RelPatternEdge = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelPatternEdge", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_RelPatternNode = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelPatternNode", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_TxDiagram = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxDiagram", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_TxKeyNode = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxKeyNode", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_TxPackageNode = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxPackageNode", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_TxParameterNode = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxParameterNode", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_TxPartNode = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxPartNode", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_TxQueryNode = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxQueryNode", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_TxTypedModelNode = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxTypedModelNode", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_UMLXModel = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("UMLXModel", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull DataTypeId DATAid_EInt = org.eclipse.qvtd.umlx.UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getDataTypeId("EInt", 0);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull IntegerValue INT_0 = org.eclipse.ocl.pivot.utilities.ValueUtil.integerValueOf("0");
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull IntegerValue INT_1 = org.eclipse.ocl.pivot.utilities.ValueUtil.integerValueOf("1");
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_PRIMid_String = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.ocl.pivot.ids.TypeId.STRING);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull TuplePartId PARTid_ = org.eclipse.ocl.pivot.ids.IdManager.getTuplePartId(1, "status", org.eclipse.ocl.pivot.ids.TypeId.BOOLEAN);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull TuplePartId PARTid__0 = org.eclipse.ocl.pivot.ids.IdManager.getTuplePartId(0, "message", org.eclipse.ocl.pivot.ids.TypeId.STRING);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SEQ_PRIMid_String = org.eclipse.ocl.pivot.ids.TypeId.SEQUENCE.getSpecializedId(org.eclipse.ocl.pivot.ids.TypeId.STRING);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SET_PRIMid_String = org.eclipse.ocl.pivot.ids.TypeId.SET.getSpecializedId(org.eclipse.ocl.pivot.ids.TypeId.STRING);
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_ = "";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelDiagram_c_c_NameIsRequired = "RelDiagram::NameIsRequired";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique = "RelDiagram::RelPatternNodeNamesAreUnique";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique_c = "RelDiagram::RelPatternNodeNamesAreUnique:";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelInvocationNode_c_c_CompatibleEdges = "RelInvocationNode::CompatibleEdges";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelInvocationNode_c_c_CompatibleEdges_32 = "RelInvocationNode::CompatibleEdges ";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternEdge_c_c_CompatibleEAttributePropertyTarget = "RelPatternEdge::CompatibleEAttributePropertyTarget";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternEdge_c_c_CompatibleEReferencePropertyTarget = "RelPatternEdge::CompatibleEReferencePropertyTarget";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternEdge_c_c_CompatibleMemberPropertyTarget = "RelPatternEdge::CompatibleMemberPropertyTarget";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternEdge_c_c_CompatiblePropertySource = "RelPatternEdge::CompatiblePropertySource";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternEdge_c_c_CompatibleRestPropertyTarget = "RelPatternEdge::CompatibleRestPropertyTarget";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternEdge_c_c_CompatibleSourceIndex = "RelPatternEdge::CompatibleSourceIndex";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternEdge_c_c_CompatibleSourceMultiplicity = "RelPatternEdge::CompatibleSourceMultiplicity";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternEdge_c_c_SourceIsClassNode = "RelPatternEdge::SourceIsClassNode";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternEdge_c_c_SourceIsEClass = "RelPatternEdge::SourceIsEClass";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternNode_c_c_AnonIsUnnamed = "RelPatternNode::AnonIsUnnamed";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternNode_c_c_EClassifierIsInTypedModel = "RelPatternNode::EClassifierIsInTypedModel";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_RelPatternNode_c_c_TypeIsRequired = "RelPatternNode::TypeIsRequired";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxDiagram_c_c_NameIsRequired = "TxDiagram::NameIsRequired";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxDiagram_c_c_RelDiagramNamesAreUnique = "TxDiagram::RelDiagramNamesAreUnique";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxDiagram_c_c_TxQueryNodeNamesAreUnique = "TxDiagram::TxQueryNodeNamesAreUnique";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxDiagram_c_c_TxTypedModelNodeNamesAreUnique = "TxDiagram::TxTypedModelNodeNamesAreUnique";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxKeyNode_c_c_PartsAreUnique = "TxKeyNode::PartsAreUnique";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxParameterNode_c_c_NameIsRequired = "TxParameterNode::NameIsRequired";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxParameterNode_c_c_TypeIsRequired = "TxParameterNode::TypeIsRequired";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxPartNode_c_c_PartIsPropertyOfKey = "TxPartNode::PartIsPropertyOfKey";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxQueryNode_c_c_NameIsRequired = "TxQueryNode::NameIsRequired";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxQueryNode_c_c_ParametersAreUnique = "TxQueryNode::ParametersAreUnique";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxQueryNode_c_c_TypeIsRequired = "TxQueryNode::TypeIsRequired";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxTypedModelNode_c_c_NameIsRequired = "TxTypedModelNode::NameIsRequired";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_TxTypedModelNode_c_c_TxPackageNodePackagesAreUnique = "TxTypedModelNode::TxPackageNodePackagesAreUnique";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR__32_39 = " \'";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR__32_are_32_not_32_unique_32_for_32 = " are not unique for ";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR__39 = "\'";
-	public static final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.NonNull String STR_quot = "/";
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId BAG_CLSSid_RelDomainNode = org.eclipse.ocl.pivot.ids.TypeId.BAG.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelDomainNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId BAG_CLSSid_RelInvocationEdge = org.eclipse.ocl.pivot.ids.TypeId.BAG.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelInvocationEdge);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId BAG_CLSSid_RelInvocationNode = org.eclipse.ocl.pivot.ids.TypeId.BAG.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelInvocationNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId BAG_CLSSid_TxTypedModelNode = org.eclipse.ocl.pivot.ids.TypeId.BAG.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_TxTypedModelNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_EClass = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_EClass);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_EClassifier = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_EClassifier);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_RelDiagram = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelDiagram);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_RelDomainNode = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelDomainNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_RelInvocationEdge = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelInvocationEdge);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_RelInvocationNode = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelInvocationNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_RelPatternEdge = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelPatternEdge);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_RelPatternNode = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelPatternNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_TxDiagram = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_TxDiagram);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_TxKeyNode = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_TxKeyNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_TxPackageNode = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_TxPackageNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_TxParameterNode = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_TxParameterNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_TxPartNode = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_TxPartNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_TxQueryNode = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_TxQueryNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_TxTypedModelNode = org.eclipse.ocl.pivot.ids.TypeId.ORDERED_SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_TxTypedModelNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SEQ_CLSSid_EClassifier = org.eclipse.ocl.pivot.ids.TypeId.SEQUENCE.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_EClassifier);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SEQ_CLSSid_EPackage = org.eclipse.ocl.pivot.ids.TypeId.SEQUENCE.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_EPackage);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SEQ_CLSSid_RelPatternNode = org.eclipse.ocl.pivot.ids.TypeId.SEQUENCE.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelPatternNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SET_CLSSid_EClass = org.eclipse.ocl.pivot.ids.TypeId.SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_EClass);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SET_CLSSid_RelPatternNode = org.eclipse.ocl.pivot.ids.TypeId.SET.getSpecializedId(org.eclipse.qvtd.umlx.UMLXTables.CLSSid_RelPatternNode);
-	public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull TupleTypeId TUPLid_ = org.eclipse.ocl.pivot.ids.IdManager.getTupleTypeId("Tuple", org.eclipse.qvtd.umlx.UMLXTables.PARTid__0, org.eclipse.qvtd.umlx.UMLXTables.PARTid_);
+	public static final /*@NonInvalid*/ @NonNull RootPackageId PACKid_$metamodel$ = IdManager.getRootPackageId("$metamodel$");
+	public static final /*@NonInvalid*/ @NonNull NsURIPackageId PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore = IdManager.getNsURIPackageId("http://www.eclipse.org/emf/2002/Ecore", null, EcorePackage.eINSTANCE);
+	public static final /*@NonInvalid*/ @NonNull NsURIPackageId PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX = IdManager.getNsURIPackageId("http://www.eclipse.org/qvt/2016/UMLX", null, UMLXPackage.eINSTANCE);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_Class = UMLXTables.PACKid_$metamodel$.getClassId("Class", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_EAttribute = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EAttribute", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_EClass = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EClass", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_EClassifier = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EClassifier", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_EPackage = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EPackage", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_EReference = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EReference", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_EStructuralFeature = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getClassId("EStructuralFeature", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_RelDiagram = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelDiagram", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_RelDomainNode = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelDomainNode", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_RelInvocationEdge = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelInvocationEdge", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_RelInvocationNode = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelInvocationNode", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_RelPatternEdge = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelPatternEdge", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_RelPatternNode = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("RelPatternNode", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_TxDiagram = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxDiagram", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_TxKeyNode = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxKeyNode", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_TxPackageNode = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxPackageNode", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_TxParameterNode = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxParameterNode", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_TxPartNode = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxPartNode", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_TxQueryNode = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxQueryNode", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_TxTypedModelNode = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("TxTypedModelNode", 0);
+	public static final /*@NonInvalid*/ @NonNull ClassId CLSSid_UMLXModel = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2016_s_UMLX.getClassId("UMLXModel", 0);
+	public static final /*@NonInvalid*/ @NonNull DataTypeId DATAid_EInt = UMLXTables.PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getDataTypeId("EInt", 0);
+	public static final /*@NonInvalid*/ @NonNull IntegerValue INT_0 = ValueUtil.integerValueOf("0");
+	public static final /*@NonInvalid*/ @NonNull IntegerValue INT_1 = ValueUtil.integerValueOf("1");
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_PRIMid_String = TypeId.ORDERED_SET.getSpecializedId(TypeId.STRING);
+	public static final /*@NonInvalid*/ @NonNull TuplePartId PARTid_ = IdManager.getTuplePartId(1, "status", TypeId.BOOLEAN);
+	public static final /*@NonInvalid*/ @NonNull TuplePartId PARTid__0 = IdManager.getTuplePartId(0, "message", TypeId.STRING);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId SEQ_PRIMid_String = TypeId.SEQUENCE.getSpecializedId(TypeId.STRING);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId SET_PRIMid_String = TypeId.SET.getSpecializedId(TypeId.STRING);
+	public static final /*@NonInvalid*/ @NonNull String STR_ = "";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelDiagram_c_c_NameIsRequired = "RelDiagram::NameIsRequired";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique = "RelDiagram::RelPatternNodeNamesAreUnique";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique_c = "RelDiagram::RelPatternNodeNamesAreUnique:";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelInvocationNode_c_c_CompatibleEdges = "RelInvocationNode::CompatibleEdges";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelInvocationNode_c_c_CompatibleEdges_32 = "RelInvocationNode::CompatibleEdges ";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternEdge_c_c_CompatibleEAttributePropertyTarget = "RelPatternEdge::CompatibleEAttributePropertyTarget";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternEdge_c_c_CompatibleEReferencePropertyTarget = "RelPatternEdge::CompatibleEReferencePropertyTarget";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternEdge_c_c_CompatibleMemberPropertyTarget = "RelPatternEdge::CompatibleMemberPropertyTarget";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternEdge_c_c_CompatiblePropertySource = "RelPatternEdge::CompatiblePropertySource";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternEdge_c_c_CompatibleRestPropertyTarget = "RelPatternEdge::CompatibleRestPropertyTarget";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternEdge_c_c_CompatibleSourceIndex = "RelPatternEdge::CompatibleSourceIndex";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternEdge_c_c_CompatibleSourceMultiplicity = "RelPatternEdge::CompatibleSourceMultiplicity";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternEdge_c_c_SourceIsClassNode = "RelPatternEdge::SourceIsClassNode";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternEdge_c_c_SourceIsEClass = "RelPatternEdge::SourceIsEClass";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternNode_c_c_AnonIsUnnamed = "RelPatternNode::AnonIsUnnamed";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternNode_c_c_EClassifierIsInTypedModel = "RelPatternNode::EClassifierIsInTypedModel";
+	public static final /*@NonInvalid*/ @NonNull String STR_RelPatternNode_c_c_TypeIsRequired = "RelPatternNode::TypeIsRequired";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxDiagram_c_c_NameIsRequired = "TxDiagram::NameIsRequired";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxDiagram_c_c_RelDiagramNamesAreUnique = "TxDiagram::RelDiagramNamesAreUnique";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxDiagram_c_c_TxQueryNodeNamesAreUnique = "TxDiagram::TxQueryNodeNamesAreUnique";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxDiagram_c_c_TxTypedModelNodeNamesAreUnique = "TxDiagram::TxTypedModelNodeNamesAreUnique";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxKeyNode_c_c_PartsAreUnique = "TxKeyNode::PartsAreUnique";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxParameterNode_c_c_NameIsRequired = "TxParameterNode::NameIsRequired";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxParameterNode_c_c_TypeIsRequired = "TxParameterNode::TypeIsRequired";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxPartNode_c_c_PartIsPropertyOfKey = "TxPartNode::PartIsPropertyOfKey";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxQueryNode_c_c_NameIsRequired = "TxQueryNode::NameIsRequired";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxQueryNode_c_c_ParametersAreUnique = "TxQueryNode::ParametersAreUnique";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxQueryNode_c_c_TypeIsRequired = "TxQueryNode::TypeIsRequired";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxTypedModelNode_c_c_NameIsRequired = "TxTypedModelNode::NameIsRequired";
+	public static final /*@NonInvalid*/ @NonNull String STR_TxTypedModelNode_c_c_TxPackageNodePackagesAreUnique = "TxTypedModelNode::TxPackageNodePackagesAreUnique";
+	public static final /*@NonInvalid*/ @NonNull String STR__32_39 = " \'";
+	public static final /*@NonInvalid*/ @NonNull String STR__32_are_32_not_32_unique_32_for_32 = " are not unique for ";
+	public static final /*@NonInvalid*/ @NonNull String STR__39 = "\'";
+	public static final /*@NonInvalid*/ @NonNull String STR_quot = "/";
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId BAG_CLSSid_RelDomainNode = TypeId.BAG.getSpecializedId(UMLXTables.CLSSid_RelDomainNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId BAG_CLSSid_RelInvocationEdge = TypeId.BAG.getSpecializedId(UMLXTables.CLSSid_RelInvocationEdge);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId BAG_CLSSid_RelInvocationNode = TypeId.BAG.getSpecializedId(UMLXTables.CLSSid_RelInvocationNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId BAG_CLSSid_TxTypedModelNode = TypeId.BAG.getSpecializedId(UMLXTables.CLSSid_TxTypedModelNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_EClass = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_EClass);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_EClassifier = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_EClassifier);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_RelDiagram = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_RelDiagram);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_RelDomainNode = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_RelDomainNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_RelInvocationEdge = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_RelInvocationEdge);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_RelInvocationNode = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_RelInvocationNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_RelPatternEdge = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_RelPatternEdge);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_RelPatternNode = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_RelPatternNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_TxDiagram = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_TxDiagram);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_TxKeyNode = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_TxKeyNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_TxPackageNode = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_TxPackageNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_TxParameterNode = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_TxParameterNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_TxPartNode = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_TxPartNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_TxQueryNode = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_TxQueryNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId ORD_CLSSid_TxTypedModelNode = TypeId.ORDERED_SET.getSpecializedId(UMLXTables.CLSSid_TxTypedModelNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId SEQ_CLSSid_EClassifier = TypeId.SEQUENCE.getSpecializedId(UMLXTables.CLSSid_EClassifier);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId SEQ_CLSSid_EPackage = TypeId.SEQUENCE.getSpecializedId(UMLXTables.CLSSid_EPackage);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId SEQ_CLSSid_RelPatternNode = TypeId.SEQUENCE.getSpecializedId(UMLXTables.CLSSid_RelPatternNode);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId SET_CLSSid_EClass = TypeId.SET.getSpecializedId(UMLXTables.CLSSid_EClass);
+	public static final /*@NonInvalid*/ @NonNull CollectionTypeId SET_CLSSid_RelPatternNode = TypeId.SET.getSpecializedId(UMLXTables.CLSSid_RelPatternNode);
+	public static final /*@NonInvalid*/ @NonNull TupleTypeId TUPLid_ = IdManager.getTupleTypeId("Tuple", UMLXTables.PARTid__0, UMLXTables.PARTid_);
 
 	/**
 	 *	The type parameters for templated types and operations.
@@ -792,12 +806,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -822,12 +836,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -852,12 +866,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -881,12 +895,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -911,12 +925,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -941,12 +955,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -970,12 +984,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1002,12 +1016,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1034,12 +1048,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1064,12 +1078,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1094,12 +1108,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1123,12 +1137,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1153,12 +1167,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1185,12 +1199,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1215,12 +1229,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1247,12 +1261,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1278,12 +1292,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1306,12 +1320,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1335,12 +1349,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
@@ -1364,12 +1378,12 @@
 			OCLstdlibTables.Operations._OclAny___lt__gt_ /* _'<>'(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny___eq_ /* _'='(OclSelf[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclAsSet /* oclAsSet() */,
-			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclAsType /* oclAsType(TT)(TT[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInState /* oclIsInState(OclState[?]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsInvalid /* oclIsInvalid() */,
-			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsKindOf /* oclIsKindOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsNew /* oclIsNew() */,
-			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[?]) */,
+			OCLstdlibTables.Operations._OclAny__oclIsTypeOf /* oclIsTypeOf(OclType[1]) */,
 			OCLstdlibTables.Operations._OclAny__oclIsUndefined /* oclIsUndefined() */,
 			OCLstdlibTables.Operations._OclAny__0_oclLog /* oclLog() */,
 			OCLstdlibTables.Operations._OclAny__1_oclLog /* oclLog(String[?]) */,
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelDiagramImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelDiagramImpl.java
index 5ad8580..ab61c6f 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelDiagramImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelDiagramImpl.java
@@ -12,6 +12,7 @@
 
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 
 import org.eclipse.emf.common.notify.Notification;
@@ -26,8 +27,9 @@
 import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.evaluation.Executor;
+import org.eclipse.ocl.pivot.ids.IdResolver;
 import org.eclipse.ocl.pivot.ids.TypeId;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.collection.CollectionAsSetOperation;
 import org.eclipse.ocl.pivot.library.collection.CollectionCountOperation;
 import org.eclipse.ocl.pivot.library.logical.BooleanNotOperation;
@@ -36,10 +38,15 @@
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
 import org.eclipse.ocl.pivot.library.string.StringConcatOperation;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
+import org.eclipse.ocl.pivot.values.IntegerValue;
 import org.eclipse.ocl.pivot.values.InvalidValueException;
+import org.eclipse.ocl.pivot.values.OrderedSetValue;
 import org.eclipse.ocl.pivot.values.SequenceValue;
+import org.eclipse.ocl.pivot.values.SequenceValue.Accumulator;
 import org.eclipse.ocl.pivot.values.SetValue;
+import org.eclipse.ocl.pivot.values.TupleValue;
 import org.eclipse.qvtd.umlx.RelDiagram;
 import org.eclipse.qvtd.umlx.RelDomainNode;
 import org.eclipse.qvtd.umlx.RelInvocationNode;
@@ -68,6 +75,14 @@
  */
 public class RelDiagramImpl extends UMLXNamedElementImpl implements RelDiagram {
 	/**
+	 * The number of structural features of the '<em>Rel Diagram</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int REL_DIAGRAM_FEATURE_COUNT = UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5;
+	/**
 	 * The default value of the '{@link #isIsAbstract() <em>Is Abstract</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -161,7 +176,7 @@
 		boolean oldIsAbstract = isAbstract;
 		isAbstract = newIsAbstract;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_DIAGRAM__IS_ABSTRACT, oldIsAbstract, isAbstract));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0, oldIsAbstract, isAbstract));
 	}
 
 	/**
@@ -184,7 +199,7 @@
 		boolean oldIsTop = isTop;
 		isTop = newIsTop;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_DIAGRAM__IS_TOP, oldIsTop, isTop));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1, oldIsTop, isTop));
 	}
 
 	/**
@@ -195,7 +210,7 @@
 	@Override
 	public EList<RelDomainNode> getOwnedRelDomainNodes() {
 		if (ownedRelDomainNodes == null) {
-			ownedRelDomainNodes = new EObjectContainmentWithInverseEList<RelDomainNode>(RelDomainNode.class, this, UMLXPackage.REL_DIAGRAM__OWNED_REL_DOMAIN_NODES, UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM);
+			ownedRelDomainNodes = new EObjectContainmentWithInverseEList<RelDomainNode>(RelDomainNode.class, this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2, RelNodeImpl.REL_NODE_FEATURE_COUNT + 3);
 		}
 		return ownedRelDomainNodes;
 	}
@@ -208,7 +223,7 @@
 	@Override
 	public EList<RelInvocationNode> getOwnedRelInvocationNodes() {
 		if (ownedRelInvocationNodes == null) {
-			ownedRelInvocationNodes = new EObjectContainmentWithInverseEList<RelInvocationNode>(RelInvocationNode.class, this, UMLXPackage.REL_DIAGRAM__OWNED_REL_INVOCATION_NODES, UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM);
+			ownedRelInvocationNodes = new EObjectContainmentWithInverseEList<RelInvocationNode>(RelInvocationNode.class, this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3, RelNodeImpl.REL_NODE_FEATURE_COUNT + 1);
 		}
 		return ownedRelInvocationNodes;
 	}
@@ -220,7 +235,7 @@
 	 */
 	@Override
 	public TxDiagram getOwningTxDiagram() {
-		if (eContainerFeatureID() != UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM) return null;
+		if (eContainerFeatureID() != (UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4)) return null;
 		return (TxDiagram)eInternalContainer();
 	}
 
@@ -230,7 +245,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningTxDiagram(TxDiagram newOwningTxDiagram, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4, msgs);
 		return msgs;
 	}
 
@@ -241,19 +256,19 @@
 	 */
 	@Override
 	public void setOwningTxDiagram(TxDiagram newOwningTxDiagram) {
-		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM && newOwningTxDiagram != null)) {
+		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != (UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4) && newOwningTxDiagram != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningTxDiagram))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningTxDiagram != null)
-				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXPackage.TX_DIAGRAM__OWNED_REL_DIAGRAMS, TxDiagram.class, msgs);
+				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0, TxDiagram.class, msgs);
 			msgs = basicSetOwningTxDiagram(newOwningTxDiagram, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM, newOwningTxDiagram, newOwningTxDiagram));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4, newOwningTxDiagram, newOwningTxDiagram));
 	}
 
 	/**
@@ -263,33 +278,38 @@
 	 */
 	@Override
 	public boolean validateNameIsRequired(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv NameIsRequired:
-		 *   let severity : Integer[1] = 'RelDiagram::NameIsRequired'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = name <> null
-		 *       in
-		 *         'RelDiagram::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelDiagram_c_c_NameIsRequired);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv NameIsRequired:
+			 *   let severity : Integer[1] = 'RelDiagram::NameIsRequired'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = name <> null
+			 *       in
+			 *         'RelDiagram::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelDiagram_c_c_NameIsRequired);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				final /*@NonInvalid*/ @Nullable String name = this.getName();
+				final /*@NonInvalid*/ boolean result = name != null;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelDiagram_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			final /*@NonInvalid*/ java.lang.@Nullable String name = this.getName();
-			final /*@NonInvalid*/ boolean result = name != null;
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelDiagram_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelDiagram::NameIsRequired", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -299,216 +319,221 @@
 	 */
 	@Override
 	public boolean validateRelPatternNodeNamesAreUnique(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv RelPatternNodeNamesAreUnique:
-		 *   let
-		 *     severity : Integer[1] = 'RelDiagram::RelPatternNodeNamesAreUnique'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let
-		 *         result : OclAny[1] = let
-		 *           allNames : Sequence(String[*|?]) = ownedRelDomainNodes.ownedRelPatternNodes->select(
-		 *             not isExpression())
-		 *           ->select(not isAnon).name
-		 *         in
-		 *           let status : Boolean[1] = allNames->isUnique(n | n)
-		 *           in
-		 *             if status = true
-		 *             then true
-		 *             else
-		 *               Tuple{
-		 *                 status = status, message = let
-		 *                   repeatedNames : Set(String[*|?]) = allNames->select(n |
-		 *                     allNames->count(n) > 1)
-		 *                   ->asSet()
-		 *                 in
-		 *                   repeatedNames->iterate(n; acc : String[1] = 'RelDiagram::RelPatternNodeNamesAreUnique:' | acc + ' \'' + n + '\'') + ' are not unique for ' + name
-		 *               }
-		 *             endif
-		 *       in
-		 *         'RelDiagram::RelPatternNodeNamesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ java.lang.@NonNull Object symbol_2;
-		if (le) {
-			symbol_2 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_symbol_1;
-			try {
-				@SuppressWarnings("null")
-				final /*@NonInvalid*/ java.util.@NonNull List<RelDomainNode> ownedRelDomainNodes = this.getOwnedRelDomainNodes();
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedRelDomainNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelDomainNode, ownedRelDomainNodes);
-				/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
-				@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedRelDomainNodes.iterator();
-				/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue collect;
-				while (true) {
-					if (!ITERATOR__1.hasNext()) {
-						collect = accumulator;
-						break;
-					}
+		try {
+			/**
+			 *
+			 * inv RelPatternNodeNamesAreUnique:
+			 *   let
+			 *     severity : Integer[1] = 'RelDiagram::RelPatternNodeNamesAreUnique'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let
+			 *         result : OclAny[1] = let
+			 *           allNames : Sequence(String[*|?]) = ownedRelDomainNodes.ownedRelPatternNodes->select(
+			 *             not isExpression())
+			 *           ->select(not isAnon).name
+			 *         in
+			 *           let status : Boolean[1] = allNames->isUnique(n | n)
+			 *           in
+			 *             if status = true
+			 *             then true
+			 *             else
+			 *               Tuple{
+			 *                 status = status, message = let
+			 *                   repeatedNames : Set(String[*|?]) = allNames->select(n |
+			 *                     allNames->count(n) > 1)
+			 *                   ->asSet()
+			 *                 in
+			 *                   repeatedNames->iterate(n; acc : String[1] = 'RelDiagram::RelPatternNodeNamesAreUnique:' | acc + ' \'' + n + '\'') + ' are not unique for ' + name
+			 *               }
+			 *             endif
+			 *       in
+			 *         'RelDiagram::RelPatternNodeNamesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ @NonNull Object symbol_2;
+			if (le) {
+				symbol_2 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @NonNull Object CAUGHT_symbol_1;
+				try {
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelDomainNode _1 = (RelDomainNode)ITERATOR__1.next();
-					/**
-					 * ownedRelPatternNodes
-					 */
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ java.util.@NonNull List<RelPatternNode> ownedRelPatternNodes = _1.getOwnedRelPatternNodes();
-					final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedRelPatternNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelPatternNode, ownedRelPatternNodes);
-					//
-					for (Object value : BOXED_ownedRelPatternNodes.flatten().getElements()) {
-						accumulator.add(value);
+					final /*@NonInvalid*/ @NonNull List<RelDomainNode> ownedRelDomainNodes = this.getOwnedRelDomainNodes();
+					final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedRelDomainNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelDomainNode, ownedRelDomainNodes);
+					/*@Thrown*/ @NonNull Accumulator accumulator = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
+					@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedRelDomainNodes.iterator();
+					/*@NonInvalid*/ @NonNull SequenceValue collect;
+					while (true) {
+						if (!ITERATOR__1.hasNext()) {
+							collect = accumulator;
+							break;
+						}
+						@SuppressWarnings("null")
+						/*@NonInvalid*/ @NonNull RelDomainNode _1 = (@NonNull RelDomainNode)ITERATOR__1.next();
+						/**
+						 * ownedRelPatternNodes
+						 */
+						@SuppressWarnings("null")
+						final /*@NonInvalid*/ @NonNull List<RelPatternNode> ownedRelPatternNodes = _1.getOwnedRelPatternNodes();
+						final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedRelPatternNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelPatternNode, ownedRelPatternNodes);
+						//
+						for (Object value : BOXED_ownedRelPatternNodes.flatten().getElements()) {
+							accumulator.add(value);
+						}
 					}
-				}
-				/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_0 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
-				@NonNull Iterator<Object> ITERATOR__1_0 = collect.iterator();
-				/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue select_0;
-				while (true) {
-					if (!ITERATOR__1_0.hasNext()) {
-						select_0 = accumulator_0;
-						break;
+					/*@Thrown*/ @NonNull Accumulator accumulator_0 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
+					@NonNull Iterator<Object> ITERATOR__1_0 = collect.iterator();
+					/*@Thrown*/ @NonNull SequenceValue select_0;
+					while (true) {
+						if (!ITERATOR__1_0.hasNext()) {
+							select_0 = accumulator_0;
+							break;
+						}
+						@SuppressWarnings("null")
+						/*@NonInvalid*/ @NonNull RelPatternNode _1_0 = (@NonNull RelPatternNode)ITERATOR__1_0.next();
+						/**
+						 * not isExpression()
+						 */
+						final /*@NonInvalid*/ boolean isExpression = _1_0.isExpression();
+						final /*@NonInvalid*/ @Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+						if (not == null) {
+							throw new InvalidValueException("Null body for \'Sequence(T).select(Sequence.T[?] | Lambda T() : Boolean[1]) : Sequence(T)\'");
+						}
+						//
+						if (not == ValueUtil.TRUE_VALUE) {
+							accumulator_0.add(_1_0);
+						}
 					}
-					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode _1_0 = (RelPatternNode)ITERATOR__1_0.next();
-					/**
-					 * not isExpression()
-					 */
-					final /*@NonInvalid*/ boolean isExpression = _1_0.isExpression();
-					final /*@NonInvalid*/ java.lang.@Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-					if (not == null) {
-						throw new InvalidValueException("Null body for \'Sequence(T).select(Sequence.T[?] | Lambda T() : Boolean[1]) : Sequence(T)\'");
+					/*@Thrown*/ @NonNull Accumulator accumulator_1 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
+					@NonNull Iterator<Object> ITERATOR__1_1 = select_0.iterator();
+					/*@Thrown*/ @NonNull SequenceValue select;
+					while (true) {
+						if (!ITERATOR__1_1.hasNext()) {
+							select = accumulator_1;
+							break;
+						}
+						@SuppressWarnings("null")
+						/*@NonInvalid*/ @NonNull RelPatternNode _1_1 = (@NonNull RelPatternNode)ITERATOR__1_1.next();
+						/**
+						 * not isAnon
+						 */
+						final /*@NonInvalid*/ boolean isAnon = _1_1.isIsAnon();
+						final /*@NonInvalid*/ @Nullable Boolean not_0 = BooleanNotOperation.INSTANCE.evaluate(isAnon);
+						if (not_0 == null) {
+							throw new InvalidValueException("Null body for \'Sequence(T).select(Sequence.T[?] | Lambda T() : Boolean[1]) : Sequence(T)\'");
+						}
+						//
+						if (not_0 == ValueUtil.TRUE_VALUE) {
+							accumulator_1.add(_1_1);
+						}
 					}
-					//
-					if (not == ValueUtil.TRUE_VALUE) {
-						accumulator_0.add(_1_0);
+					/*@Thrown*/ @NonNull Accumulator accumulator_2 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_PRIMid_String);
+					@NonNull Iterator<Object> ITERATOR__1_2 = select.iterator();
+					/*@Thrown*/ @NonNull SequenceValue allNames;
+					while (true) {
+						if (!ITERATOR__1_2.hasNext()) {
+							allNames = accumulator_2;
+							break;
+						}
+						@SuppressWarnings("null")
+						/*@NonInvalid*/ @NonNull RelPatternNode _1_2 = (@NonNull RelPatternNode)ITERATOR__1_2.next();
+						/**
+						 * name
+						 */
+						final /*@NonInvalid*/ @Nullable String name = _1_2.getName();
+						//
+						accumulator_2.add(name);
 					}
-				}
-				/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_1 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
-				@NonNull Iterator<Object> ITERATOR__1_1 = select_0.iterator();
-				/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue select;
-				while (true) {
-					if (!ITERATOR__1_1.hasNext()) {
-						select = accumulator_1;
-						break;
+					/*@Thrown*/ org.eclipse.ocl.pivot.values.SetValue.@NonNull Accumulator accumulator_3 = ValueUtil.createSetAccumulatorValue(UMLXTables.SEQ_PRIMid_String);
+					@Nullable Iterator<Object> ITERATOR_n = allNames.iterator();
+					/*@Thrown*/ boolean status;
+					while (true) {
+						if (!ITERATOR_n.hasNext()) {
+							status = ValueUtil.TRUE_VALUE;
+							break;
+						}
+						/*@NonInvalid*/ @Nullable String n = (@Nullable String)ITERATOR_n.next();
+						/**
+						 * n
+						 */
+						//
+						if (accumulator_3.includes(n) == ValueUtil.TRUE_VALUE) {
+							status = ValueUtil.FALSE_VALUE;			// Abort after second find
+							break;
+						}
+						else {
+							accumulator_3.add(n);
+						}
 					}
-					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode _1_1 = (RelPatternNode)ITERATOR__1_1.next();
-					/**
-					 * not isAnon
-					 */
-					final /*@NonInvalid*/ boolean isAnon = _1_1.isIsAnon();
-					final /*@NonInvalid*/ java.lang.@Nullable Boolean not_0 = BooleanNotOperation.INSTANCE.evaluate(isAnon);
-					if (not_0 == null) {
-						throw new InvalidValueException("Null body for \'Sequence(T).select(Sequence.T[?] | Lambda T() : Boolean[1]) : Sequence(T)\'");
-					}
-					//
-					if (not_0 == ValueUtil.TRUE_VALUE) {
-						accumulator_1.add(_1_1);
-					}
-				}
-				/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_2 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_PRIMid_String);
-				@NonNull Iterator<Object> ITERATOR__1_2 = select.iterator();
-				/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue allNames;
-				while (true) {
-					if (!ITERATOR__1_2.hasNext()) {
-						allNames = accumulator_2;
-						break;
-					}
-					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode _1_2 = (RelPatternNode)ITERATOR__1_2.next();
-					/**
-					 * name
-					 */
-					final /*@NonInvalid*/ java.lang.@Nullable String name = _1_2.getName();
-					//
-					accumulator_2.add(name);
-				}
-				/*@Thrown*/ SetValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_3 = ValueUtil.createSetAccumulatorValue(UMLXTables.SEQ_PRIMid_String);
-				@Nullable Iterator<Object> ITERATOR_n = allNames.iterator();
-				/*@Thrown*/ boolean status;
-				while (true) {
-					if (!ITERATOR_n.hasNext()) {
-						status = ValueUtil.TRUE_VALUE;
-						break;
-					}
-					/*@NonInvalid*/ java.lang.@Nullable String n = (String)ITERATOR_n.next();
-					/**
-					 * n
-					 */
-					//
-					if (accumulator_3.includes(n) == ValueUtil.TRUE_VALUE) {
-						status = ValueUtil.FALSE_VALUE;			// Abort after second find
-						break;
+					/*@Thrown*/ @NonNull Object symbol_1;
+					if (status) {
+						symbol_1 = ValueUtil.TRUE_VALUE;
 					}
 					else {
-						accumulator_3.add(n);
-					}
-				}
-				/*@Thrown*/ java.lang.@NonNull Object symbol_1;
-				if (status) {
-					symbol_1 = ValueUtil.TRUE_VALUE;
-				}
-				else {
-					/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_4 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_PRIMid_String);
-					@Nullable Iterator<Object> ITERATOR_n_0 = allNames.iterator();
-					/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue select_1;
-					while (true) {
-						if (!ITERATOR_n_0.hasNext()) {
-							select_1 = accumulator_4;
-							break;
+						/*@Thrown*/ @NonNull Accumulator accumulator_4 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_PRIMid_String);
+						@Nullable Iterator<Object> ITERATOR_n_0 = allNames.iterator();
+						/*@Thrown*/ @NonNull SequenceValue select_1;
+						while (true) {
+							if (!ITERATOR_n_0.hasNext()) {
+								select_1 = accumulator_4;
+								break;
+							}
+							/*@NonInvalid*/ @Nullable String n_0 = (@Nullable String)ITERATOR_n_0.next();
+							/**
+							 * allNames->count(n) > 1
+							 */
+							final /*@Thrown*/ @NonNull IntegerValue count = CollectionCountOperation.INSTANCE.evaluate(allNames, n_0);
+							final /*@Thrown*/ boolean gt = OclComparableGreaterThanOperation.INSTANCE.evaluate(executor, count, UMLXTables.INT_1).booleanValue();
+							//
+							if (gt == ValueUtil.TRUE_VALUE) {
+								accumulator_4.add(n_0);
+							}
 						}
-						/*@NonInvalid*/ java.lang.@Nullable String n_0 = (String)ITERATOR_n_0.next();
-						/**
-						 * allNames->count(n) > 1
-						 */
-						final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue count = CollectionCountOperation.INSTANCE.evaluate(allNames, n_0);
-						final /*@Thrown*/ boolean gt = OclComparableGreaterThanOperation.INSTANCE.evaluate(executor, count, UMLXTables.INT_1).booleanValue();
-						//
-						if (gt == ValueUtil.TRUE_VALUE) {
-							accumulator_4.add(n_0);
+						final /*@Thrown*/ @NonNull SetValue repeatedNames = CollectionAsSetOperation.INSTANCE.evaluate(select_1);
+						/*@NonInvalid*/ @NonNull String acc = UMLXTables.STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique_c;
+						@Nullable Iterator<Object> ITERATOR_n_1 = repeatedNames.iterator();
+						/*@Thrown*/ @Nullable String iterate;
+						while (true) {
+							if (!ITERATOR_n_1.hasNext()) {
+								iterate = acc;
+								break;
+							}
+							/*@NonInvalid*/ @Nullable String n_1 = (@Nullable String)ITERATOR_n_1.next();
+							/**
+							 * acc + ' \'' + n + '\''
+							 */
+							final /*@NonInvalid*/ @NonNull String sum = StringConcatOperation.INSTANCE.evaluate(acc, UMLXTables.STR__32_39);
+							final /*@Thrown*/ @NonNull String sum_0 = StringConcatOperation.INSTANCE.evaluate(sum, n_1);
+							final /*@Thrown*/ @NonNull String sum_1 = StringConcatOperation.INSTANCE.evaluate(sum_0, UMLXTables.STR__39);
+							//
+							acc = sum_1;
 						}
+						final /*@Thrown*/ @NonNull String sum_2 = StringConcatOperation.INSTANCE.evaluate(iterate, UMLXTables.STR__32_are_32_not_32_unique_32_for_32);
+						final /*@NonInvalid*/ @Nullable String name_0 = this.getName();
+						final /*@Thrown*/ @NonNull String sum_3 = StringConcatOperation.INSTANCE.evaluate(sum_2, name_0);
+						final /*@Thrown*/ @NonNull TupleValue symbol_0 = ValueUtil.createTupleOfEach(UMLXTables.TUPLid_, sum_3, status);
+						symbol_1 = symbol_0;
 					}
-					final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue repeatedNames = CollectionAsSetOperation.INSTANCE.evaluate(select_1);
-					/*@NonInvalid*/ java.lang.@NonNull String acc = UMLXTables.STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique_c;
-					@Nullable Iterator<Object> ITERATOR_n_1 = repeatedNames.iterator();
-					/*@Thrown*/ java.lang.@Nullable String iterate;
-					while (true) {
-						if (!ITERATOR_n_1.hasNext()) {
-							iterate = acc;
-							break;
-						}
-						/*@NonInvalid*/ java.lang.@Nullable String n_1 = (String)ITERATOR_n_1.next();
-						/**
-						 * acc + ' \'' + n + '\''
-						 */
-						final /*@NonInvalid*/ java.lang.@NonNull String sum = StringConcatOperation.INSTANCE.evaluate(acc, UMLXTables.STR__32_39);
-						final /*@Thrown*/ java.lang.@NonNull String sum_0 = StringConcatOperation.INSTANCE.evaluate(sum, n_1);
-						final /*@Thrown*/ java.lang.@NonNull String sum_1 = StringConcatOperation.INSTANCE.evaluate(sum_0, UMLXTables.STR__39);
-						//
-						acc = sum_1;
-					}
-					final /*@Thrown*/ java.lang.@NonNull String sum_2 = StringConcatOperation.INSTANCE.evaluate(iterate, UMLXTables.STR__32_are_32_not_32_unique_32_for_32);
-					final /*@NonInvalid*/ java.lang.@Nullable String name_0 = this.getName();
-					final /*@Thrown*/ java.lang.@NonNull String sum_3 = StringConcatOperation.INSTANCE.evaluate(sum_2, name_0);
-					final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull TupleValue symbol_0 = ValueUtil.createTupleOfEach(UMLXTables.TUPLid_, sum_3, status);
-					symbol_1 = symbol_0;
+					CAUGHT_symbol_1 = symbol_1;
 				}
-				CAUGHT_symbol_1 = symbol_1;
+				catch (Exception e) {
+					CAUGHT_symbol_1 = ValueUtil.createInvalidValue(e);
+				}
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_symbol_1, UMLXTables.INT_0).booleanValue();
+				symbol_2 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_symbol_1 = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelDiagram_c_c_RelPatternNodeNamesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_symbol_1, UMLXTables.INT_0).booleanValue();
-			symbol_2 = logDiagnostic;
+			return Boolean.TRUE == symbol_2;
 		}
-		return Boolean.TRUE == symbol_2;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelDiagram::RelPatternNodeNamesAreUnique", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -519,15 +544,15 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.REL_DIAGRAM__IS_ABSTRACT:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				return isIsAbstract();
-			case UMLXPackage.REL_DIAGRAM__IS_TOP:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				return isIsTop();
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_DOMAIN_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return getOwnedRelDomainNodes();
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_INVOCATION_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return getOwnedRelInvocationNodes();
-			case UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				return getOwningTxDiagram();
 		}
 		return super.eGet(featureID, resolve, coreType);
@@ -542,21 +567,21 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.REL_DIAGRAM__IS_ABSTRACT:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				setIsAbstract((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_DIAGRAM__IS_TOP:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				setIsTop((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_DOMAIN_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				getOwnedRelDomainNodes().clear();
 				getOwnedRelDomainNodes().addAll((Collection<? extends RelDomainNode>)newValue);
 				return;
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_INVOCATION_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				getOwnedRelInvocationNodes().clear();
 				getOwnedRelInvocationNodes().addAll((Collection<? extends RelInvocationNode>)newValue);
 				return;
-			case UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				setOwningTxDiagram((TxDiagram)newValue);
 				return;
 		}
@@ -571,19 +596,19 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_DIAGRAM__IS_ABSTRACT:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				setIsAbstract(IS_ABSTRACT_EDEFAULT);
 				return;
-			case UMLXPackage.REL_DIAGRAM__IS_TOP:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				setIsTop(IS_TOP_EDEFAULT);
 				return;
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_DOMAIN_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				getOwnedRelDomainNodes().clear();
 				return;
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_INVOCATION_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				getOwnedRelInvocationNodes().clear();
 				return;
-			case UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				setOwningTxDiagram((TxDiagram)null);
 				return;
 		}
@@ -598,15 +623,15 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_DIAGRAM__IS_ABSTRACT:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				return isAbstract != IS_ABSTRACT_EDEFAULT;
-			case UMLXPackage.REL_DIAGRAM__IS_TOP:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				return isTop != IS_TOP_EDEFAULT;
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_DOMAIN_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return ownedRelDomainNodes != null && !ownedRelDomainNodes.isEmpty();
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_INVOCATION_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return ownedRelInvocationNodes != null && !ownedRelInvocationNodes.isEmpty();
-			case UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				return getOwningTxDiagram() != null;
 		}
 		return super.eIsSet(featureID);
@@ -628,7 +653,15 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (isAbstract: ");
+		result.append(isAbstract);
+		result.append(", isTop: ");
+		result.append(isTop);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -640,11 +673,11 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_DOMAIN_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedRelDomainNodes()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_INVOCATION_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedRelInvocationNodes()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningTxDiagram((TxDiagram)otherEnd, msgs);
@@ -660,11 +693,11 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_DOMAIN_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return ((InternalEList<?>)getOwnedRelDomainNodes()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.REL_DIAGRAM__OWNED_REL_INVOCATION_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return ((InternalEList<?>)getOwnedRelInvocationNodes()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				return basicSetOwningTxDiagram(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -678,8 +711,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.TX_DIAGRAM__OWNED_REL_DIAGRAMS, TxDiagram.class, msgs);
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
+				return eInternalContainer().eInverseRemove(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0, TxDiagram.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelDomainNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelDomainNodeImpl.java
index 038e92d..d7607c6 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelDomainNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelDomainNodeImpl.java
@@ -49,6 +49,15 @@
  */
 public class RelDomainNodeImpl extends RelNodeImpl implements RelDomainNode {
 	/**
+	 * The number of structural features of the '<em>Rel Domain Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int REL_DOMAIN_NODE_FEATURE_COUNT = RelNodeImpl.REL_NODE_FEATURE_COUNT + 5;
+
+	/**
 	 * The default value of the '{@link #isIsEnforced() <em>Is Enforced</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -137,7 +146,7 @@
 		boolean oldIsEnforced = isEnforced;
 		isEnforced = newIsEnforced;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_DOMAIN_NODE__IS_ENFORCED, oldIsEnforced, isEnforced));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 0, oldIsEnforced, isEnforced));
 	}
 
 	/**
@@ -148,7 +157,7 @@
 	@Override
 	public EList<RelPatternEdge> getOwnedRelPatternEdges() {
 		if (ownedRelPatternEdges == null) {
-			ownedRelPatternEdges = new EObjectContainmentWithInverseEList<RelPatternEdge>(RelPatternEdge.class, this, UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES, UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE);
+			ownedRelPatternEdges = new EObjectContainmentWithInverseEList<RelPatternEdge>(RelPatternEdge.class, this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 1, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0);
 		}
 		return ownedRelPatternEdges;
 	}
@@ -161,7 +170,7 @@
 	@Override
 	public EList<RelPatternNode> getOwnedRelPatternNodes() {
 		if (ownedRelPatternNodes == null) {
-			ownedRelPatternNodes = new EObjectContainmentWithInverseEList<RelPatternNode>(RelPatternNode.class, this, UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES, UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE);
+			ownedRelPatternNodes = new EObjectContainmentWithInverseEList<RelPatternNode>(RelPatternNode.class, this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 2, RelNodeImpl.REL_NODE_FEATURE_COUNT + 13);
 		}
 		return ownedRelPatternNodes;
 	}
@@ -173,7 +182,7 @@
 	 */
 	@Override
 	public RelDiagram getOwningRelDiagram() {
-		if (eContainerFeatureID() != UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM) return null;
+		if (eContainerFeatureID() != (RelNodeImpl.REL_NODE_FEATURE_COUNT + 3)) return null;
 		return (RelDiagram)eInternalContainer();
 	}
 
@@ -183,7 +192,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningRelDiagram(RelDiagram newOwningRelDiagram, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningRelDiagram, UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningRelDiagram, RelNodeImpl.REL_NODE_FEATURE_COUNT + 3, msgs);
 		return msgs;
 	}
 
@@ -194,19 +203,19 @@
 	 */
 	@Override
 	public void setOwningRelDiagram(RelDiagram newOwningRelDiagram) {
-		if (newOwningRelDiagram != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM && newOwningRelDiagram != null)) {
+		if (newOwningRelDiagram != eInternalContainer() || (eContainerFeatureID() != (RelNodeImpl.REL_NODE_FEATURE_COUNT + 3) && newOwningRelDiagram != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningRelDiagram))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningRelDiagram != null)
-				msgs = ((InternalEObject)newOwningRelDiagram).eInverseAdd(this, UMLXPackage.REL_DIAGRAM__OWNED_REL_DOMAIN_NODES, RelDiagram.class, msgs);
+				msgs = ((InternalEObject)newOwningRelDiagram).eInverseAdd(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2, RelDiagram.class, msgs);
 			msgs = basicSetOwningRelDiagram(newOwningRelDiagram, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM, newOwningRelDiagram, newOwningRelDiagram));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 3, newOwningRelDiagram, newOwningRelDiagram));
 	}
 
 	/**
@@ -221,7 +230,7 @@
 			referredTxTypedModelNode = (TxTypedModelNode)eResolveProxy(oldReferredTxTypedModelNode);
 			if (referredTxTypedModelNode != oldReferredTxTypedModelNode) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.REL_DOMAIN_NODE__REFERRED_TX_TYPED_MODEL_NODE, oldReferredTxTypedModelNode, referredTxTypedModelNode));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, RelNodeImpl.REL_NODE_FEATURE_COUNT + 4, oldReferredTxTypedModelNode, referredTxTypedModelNode));
 			}
 		}
 		return referredTxTypedModelNode;
@@ -246,7 +255,7 @@
 		TxTypedModelNode oldReferredTxTypedModelNode = referredTxTypedModelNode;
 		referredTxTypedModelNode = newReferredTxTypedModelNode;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_DOMAIN_NODE__REFERRED_TX_TYPED_MODEL_NODE, oldReferredTxTypedModelNode, referredTxTypedModelNode));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 4, oldReferredTxTypedModelNode, referredTxTypedModelNode));
 	}
 
 	/**
@@ -256,7 +265,13 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (isEnforced: ");
+		result.append(isEnforced);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -268,11 +283,11 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedRelPatternEdges()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedRelPatternNodes()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningRelDiagram((RelDiagram)otherEnd, msgs);
@@ -288,11 +303,11 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				return ((InternalEList<?>)getOwnedRelPatternEdges()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return ((InternalEList<?>)getOwnedRelPatternNodes()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				return basicSetOwningRelDiagram(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -306,8 +321,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.REL_DIAGRAM__OWNED_REL_DOMAIN_NODES, RelDiagram.class, msgs);
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
+				return eInternalContainer().eInverseRemove(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2, RelDiagram.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -320,15 +335,15 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.REL_DOMAIN_NODE__IS_ENFORCED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				return isIsEnforced();
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				return getOwnedRelPatternEdges();
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return getOwnedRelPatternNodes();
-			case UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				return getOwningRelDiagram();
-			case UMLXPackage.REL_DOMAIN_NODE__REFERRED_TX_TYPED_MODEL_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 4:
 				if (resolve) return getReferredTxTypedModelNode();
 				return basicGetReferredTxTypedModelNode();
 		}
@@ -344,21 +359,21 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.REL_DOMAIN_NODE__IS_ENFORCED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				setIsEnforced((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				getOwnedRelPatternEdges().clear();
 				getOwnedRelPatternEdges().addAll((Collection<? extends RelPatternEdge>)newValue);
 				return;
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				getOwnedRelPatternNodes().clear();
 				getOwnedRelPatternNodes().addAll((Collection<? extends RelPatternNode>)newValue);
 				return;
-			case UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				setOwningRelDiagram((RelDiagram)newValue);
 				return;
-			case UMLXPackage.REL_DOMAIN_NODE__REFERRED_TX_TYPED_MODEL_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 4:
 				setReferredTxTypedModelNode((TxTypedModelNode)newValue);
 				return;
 		}
@@ -373,19 +388,19 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_DOMAIN_NODE__IS_ENFORCED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				setIsEnforced(IS_ENFORCED_EDEFAULT);
 				return;
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				getOwnedRelPatternEdges().clear();
 				return;
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				getOwnedRelPatternNodes().clear();
 				return;
-			case UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				setOwningRelDiagram((RelDiagram)null);
 				return;
-			case UMLXPackage.REL_DOMAIN_NODE__REFERRED_TX_TYPED_MODEL_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 4:
 				setReferredTxTypedModelNode((TxTypedModelNode)null);
 				return;
 		}
@@ -400,15 +415,15 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_DOMAIN_NODE__IS_ENFORCED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				return isEnforced != IS_ENFORCED_EDEFAULT;
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				return ownedRelPatternEdges != null && !ownedRelPatternEdges.isEmpty();
-			case UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return ownedRelPatternNodes != null && !ownedRelPatternNodes.isEmpty();
-			case UMLXPackage.REL_DOMAIN_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				return getOwningRelDiagram() != null;
-			case UMLXPackage.REL_DOMAIN_NODE__REFERRED_TX_TYPED_MODEL_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 4:
 				return referredTxTypedModelNode != null;
 		}
 		return super.eIsSet(featureID);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelEdgeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelEdgeImpl.java
index 46bc03f..ab17e0b 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelEdgeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelEdgeImpl.java
@@ -23,6 +23,15 @@
  */
 public abstract class RelEdgeImpl extends UMLXElementImpl implements RelEdge {
 	/**
+	 * The number of structural features of the '<em>Rel Edge</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int REL_EDGE_FEATURE_COUNT = UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0;
+
+	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelInvocationEdgeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelInvocationEdgeImpl.java
index 95166ff..125e173 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelInvocationEdgeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelInvocationEdgeImpl.java
@@ -40,6 +40,15 @@
  */
 public class RelInvocationEdgeImpl extends RelEdgeImpl implements RelInvocationEdge {
 	/**
+	 * The number of structural features of the '<em>Rel Invocation Edge</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int REL_INVOCATION_EDGE_FEATURE_COUNT = RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 3;
+
+	/**
 	 * The cached value of the '{@link #getInvokingRelPatternNode() <em>Invoking Rel Pattern Node</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -90,7 +99,7 @@
 			referredRelPatternNode = (RelPatternNode)eResolveProxy(oldReferredRelPatternNode);
 			if (referredRelPatternNode != oldReferredRelPatternNode) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.REL_INVOCATION_EDGE__REFERRED_REL_PATTERN_NODE, oldReferredRelPatternNode, referredRelPatternNode));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2, oldReferredRelPatternNode, referredRelPatternNode));
 			}
 		}
 		return referredRelPatternNode;
@@ -115,7 +124,7 @@
 		RelPatternNode oldReferredRelPatternNode = referredRelPatternNode;
 		referredRelPatternNode = newReferredRelPatternNode;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_INVOCATION_EDGE__REFERRED_REL_PATTERN_NODE, oldReferredRelPatternNode, referredRelPatternNode));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2, oldReferredRelPatternNode, referredRelPatternNode));
 	}
 
 	/**
@@ -125,7 +134,7 @@
 	 */
 	@Override
 	public RelInvocationNode getOwningRelInvocationNode() {
-		if (eContainerFeatureID() != UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE) return null;
+		if (eContainerFeatureID() != (RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1)) return null;
 		return (RelInvocationNode)eInternalContainer();
 	}
 
@@ -135,7 +144,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningRelInvocationNode(RelInvocationNode newOwningRelInvocationNode, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningRelInvocationNode, UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningRelInvocationNode, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1, msgs);
 		return msgs;
 	}
 
@@ -146,19 +155,19 @@
 	 */
 	@Override
 	public void setOwningRelInvocationNode(RelInvocationNode newOwningRelInvocationNode) {
-		if (newOwningRelInvocationNode != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE && newOwningRelInvocationNode != null)) {
+		if (newOwningRelInvocationNode != eInternalContainer() || (eContainerFeatureID() != (RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1) && newOwningRelInvocationNode != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningRelInvocationNode))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningRelInvocationNode != null)
-				msgs = ((InternalEObject)newOwningRelInvocationNode).eInverseAdd(this, UMLXPackage.REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES, RelInvocationNode.class, msgs);
+				msgs = ((InternalEObject)newOwningRelInvocationNode).eInverseAdd(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 2, RelInvocationNode.class, msgs);
 			msgs = basicSetOwningRelInvocationNode(newOwningRelInvocationNode, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE, newOwningRelInvocationNode, newOwningRelInvocationNode));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1, newOwningRelInvocationNode, newOwningRelInvocationNode));
 	}
 
 	/**
@@ -173,7 +182,7 @@
 			invokingRelPatternNode = (RelPatternNode)eResolveProxy(oldInvokingRelPatternNode);
 			if (invokingRelPatternNode != oldInvokingRelPatternNode) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE, oldInvokingRelPatternNode, invokingRelPatternNode));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0, oldInvokingRelPatternNode, invokingRelPatternNode));
 			}
 		}
 		return invokingRelPatternNode;
@@ -197,7 +206,7 @@
 		RelPatternNode oldInvokingRelPatternNode = invokingRelPatternNode;
 		invokingRelPatternNode = newInvokingRelPatternNode;
 		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE, oldInvokingRelPatternNode, newInvokingRelPatternNode);
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0, oldInvokingRelPatternNode, newInvokingRelPatternNode);
 			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
@@ -213,14 +222,14 @@
 		if (newInvokingRelPatternNode != invokingRelPatternNode) {
 			NotificationChain msgs = null;
 			if (invokingRelPatternNode != null)
-				msgs = ((InternalEObject)invokingRelPatternNode).eInverseRemove(this, UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES, RelPatternNode.class, msgs);
+				msgs = ((InternalEObject)invokingRelPatternNode).eInverseRemove(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 9, RelPatternNode.class, msgs);
 			if (newInvokingRelPatternNode != null)
-				msgs = ((InternalEObject)newInvokingRelPatternNode).eInverseAdd(this, UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES, RelPatternNode.class, msgs);
+				msgs = ((InternalEObject)newInvokingRelPatternNode).eInverseAdd(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 9, RelPatternNode.class, msgs);
 			msgs = basicSetInvokingRelPatternNode(newInvokingRelPatternNode, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE, newInvokingRelPatternNode, newInvokingRelPatternNode));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0, newInvokingRelPatternNode, newInvokingRelPatternNode));
 	}
 
 	/**
@@ -231,11 +240,11 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				if (invokingRelPatternNode != null)
-					msgs = ((InternalEObject)invokingRelPatternNode).eInverseRemove(this, UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES, RelPatternNode.class, msgs);
+					msgs = ((InternalEObject)invokingRelPatternNode).eInverseRemove(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 9, RelPatternNode.class, msgs);
 				return basicSetInvokingRelPatternNode((RelPatternNode)otherEnd, msgs);
-			case UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningRelInvocationNode((RelInvocationNode)otherEnd, msgs);
@@ -251,9 +260,9 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				return basicSetInvokingRelPatternNode(null, msgs);
-			case UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				return basicSetOwningRelInvocationNode(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -267,8 +276,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES, RelInvocationNode.class, msgs);
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
+				return eInternalContainer().eInverseRemove(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 2, RelInvocationNode.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -281,12 +290,12 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				if (resolve) return getInvokingRelPatternNode();
 				return basicGetInvokingRelPatternNode();
-			case UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				return getOwningRelInvocationNode();
-			case UMLXPackage.REL_INVOCATION_EDGE__REFERRED_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				if (resolve) return getReferredRelPatternNode();
 				return basicGetReferredRelPatternNode();
 		}
@@ -301,13 +310,13 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				setInvokingRelPatternNode((RelPatternNode)newValue);
 				return;
-			case UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				setOwningRelInvocationNode((RelInvocationNode)newValue);
 				return;
-			case UMLXPackage.REL_INVOCATION_EDGE__REFERRED_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				setReferredRelPatternNode((RelPatternNode)newValue);
 				return;
 		}
@@ -322,13 +331,13 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				setInvokingRelPatternNode((RelPatternNode)null);
 				return;
-			case UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				setOwningRelInvocationNode((RelInvocationNode)null);
 				return;
-			case UMLXPackage.REL_INVOCATION_EDGE__REFERRED_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				setReferredRelPatternNode((RelPatternNode)null);
 				return;
 		}
@@ -343,11 +352,11 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				return invokingRelPatternNode != null;
-			case UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				return getOwningRelInvocationNode() != null;
-			case UMLXPackage.REL_INVOCATION_EDGE__REFERRED_REL_PATTERN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				return referredRelPatternNode != null;
 		}
 		return super.eIsSet(featureID);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelInvocationNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelInvocationNodeImpl.java
index 93b7daa..09ac4cd 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelInvocationNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelInvocationNodeImpl.java
@@ -12,6 +12,7 @@
 
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
@@ -24,8 +25,9 @@
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.ocl.pivot.evaluation.Executor;
+import org.eclipse.ocl.pivot.ids.IdResolver;
 import org.eclipse.ocl.pivot.ids.TypeId;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.collection.CollectionAsSetOperation;
 import org.eclipse.ocl.pivot.library.collection.CollectionSizeOperation;
 import org.eclipse.ocl.pivot.library.oclany.OclAnyToStringOperation;
@@ -33,8 +35,14 @@
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
 import org.eclipse.ocl.pivot.library.string.StringConcatOperation;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
+import org.eclipse.ocl.pivot.values.IntegerValue;
+import org.eclipse.ocl.pivot.values.OrderedSetValue;
 import org.eclipse.ocl.pivot.values.SequenceValue;
+import org.eclipse.ocl.pivot.values.SequenceValue.Accumulator;
+import org.eclipse.ocl.pivot.values.SetValue;
+import org.eclipse.ocl.pivot.values.TupleValue;
 import org.eclipse.qvtd.umlx.RelDiagram;
 import org.eclipse.qvtd.umlx.RelDomainNode;
 import org.eclipse.qvtd.umlx.RelInvocationEdge;
@@ -62,6 +70,15 @@
  */
 public class RelInvocationNodeImpl extends RelNodeImpl implements RelInvocationNode {
 	/**
+	 * The number of structural features of the '<em>Rel Invocation Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int REL_INVOCATION_NODE_FEATURE_COUNT = RelNodeImpl.REL_NODE_FEATURE_COUNT + 4;
+
+	/**
 	 * The default value of the '{@link #isIsThen() <em>Is Then</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -140,7 +157,7 @@
 		boolean oldIsThen = isThen;
 		isThen = newIsThen;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_INVOCATION_NODE__IS_THEN, oldIsThen, isThen));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 0, oldIsThen, isThen));
 	}
 
 	/**
@@ -155,7 +172,7 @@
 			referredRelDiagram = (RelDiagram)eResolveProxy(oldReferredRelDiagram);
 			if (referredRelDiagram != oldReferredRelDiagram) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.REL_INVOCATION_NODE__REFERRED_REL_DIAGRAM, oldReferredRelDiagram, referredRelDiagram));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, RelNodeImpl.REL_NODE_FEATURE_COUNT + 3, oldReferredRelDiagram, referredRelDiagram));
 			}
 		}
 		return referredRelDiagram;
@@ -180,7 +197,7 @@
 		RelDiagram oldReferredRelDiagram = referredRelDiagram;
 		referredRelDiagram = newReferredRelDiagram;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_INVOCATION_NODE__REFERRED_REL_DIAGRAM, oldReferredRelDiagram, referredRelDiagram));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 3, oldReferredRelDiagram, referredRelDiagram));
 	}
 
 	/**
@@ -190,86 +207,85 @@
 	 */
 	@Override
 	public boolean validateCompatibleEdges(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv CompatibleEdges:
-		 *   let
-		 *     severity : Integer[1] = 'RelInvocationNode::CompatibleEdges'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let
-		 *         result : OclAny[1] = let
-		 *           expectedNodes : Set(umlx::RelPatternNode) = referredRelDiagram.ownedRelDomainNodes.ownedRelPatternNodes->select(isRoot)
-		 *           ->asSet()
-		 *         in
-		 *           let
-		 *             actualNodes : Set(umlx::RelPatternNode) = ownedRelInvocationEdges.referredRelPatternNode->asSet()
-		 *           in
-		 *             let status : Boolean[1] = expectedNodes = actualNodes
-		 *             in
-		 *               if status = true
-		 *               then true
-		 *               else
-		 *                 Tuple{status = status, message = 'RelInvocationNode::CompatibleEdges ' +
-		 *                   expectedNodes->size()
-		 *                   .toString() + '/' +
-		 *                   expectedNodes->size()
-		 *                   .toString()
-		 *                 }
-		 *               endif
-		 *       in
-		 *         'RelInvocationNode::CompatibleEdges'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelInvocationNode_c_c_CompatibleEdges);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ java.lang.@NonNull Object symbol_2;
-		if (le) {
-			symbol_2 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_symbol_1;
-			try {
+		try {
+			/**
+			 *
+			 * inv CompatibleEdges:
+			 *   let
+			 *     severity : Integer[1] = 'RelInvocationNode::CompatibleEdges'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let
+			 *         result : OclAny[1] = let
+			 *           expectedNodes : Set(umlx::RelPatternNode) = referredRelDiagram.ownedRelDomainNodes.ownedRelPatternNodes->select(isRoot)
+			 *           ->asSet()
+			 *         in
+			 *           let
+			 *             actualNodes : Set(umlx::RelPatternNode) = ownedRelInvocationEdges.referredRelPatternNode->asSet()
+			 *           in
+			 *             let status : Boolean[1] = expectedNodes = actualNodes
+			 *             in
+			 *               if status = true
+			 *               then true
+			 *               else
+			 *                 Tuple{status = status, message = 'RelInvocationNode::CompatibleEdges ' +
+			 *                   expectedNodes->size()
+			 *                   .toString() + '/' +
+			 *                   expectedNodes->size()
+			 *                   .toString()
+			 *                 }
+			 *               endif
+			 *       in
+			 *         'RelInvocationNode::CompatibleEdges'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelInvocationNode_c_c_CompatibleEdges);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ @NonNull Object symbol_2;
+			if (le) {
+				symbol_2 = ValueUtil.TRUE_VALUE;
+			}
+			else {
 				@SuppressWarnings("null")
-				final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelDiagram referredRelDiagram = this.getReferredRelDiagram();
+				final /*@NonInvalid*/ @NonNull RelDiagram referredRelDiagram = this.getReferredRelDiagram();
 				@SuppressWarnings("null")
-				final /*@NonInvalid*/ java.util.@NonNull List<RelDomainNode> ownedRelDomainNodes = referredRelDiagram.getOwnedRelDomainNodes();
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedRelDomainNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelDomainNode, ownedRelDomainNodes);
-				/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
+				final /*@NonInvalid*/ @NonNull List<RelDomainNode> ownedRelDomainNodes = referredRelDiagram.getOwnedRelDomainNodes();
+				final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedRelDomainNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelDomainNode, ownedRelDomainNodes);
+				/*@Thrown*/ @NonNull Accumulator accumulator = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
 				@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedRelDomainNodes.iterator();
-				/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue collect;
+				/*@NonInvalid*/ @NonNull SequenceValue collect;
 				while (true) {
 					if (!ITERATOR__1.hasNext()) {
 						collect = accumulator;
 						break;
 					}
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelDomainNode _1 = (RelDomainNode)ITERATOR__1.next();
+					/*@NonInvalid*/ @NonNull RelDomainNode _1 = (@NonNull RelDomainNode)ITERATOR__1.next();
 					/**
 					 * ownedRelPatternNodes
 					 */
 					@SuppressWarnings("null")
-					final /*@NonInvalid*/ java.util.@NonNull List<RelPatternNode> ownedRelPatternNodes = _1.getOwnedRelPatternNodes();
-					final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedRelPatternNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelPatternNode, ownedRelPatternNodes);
+					final /*@NonInvalid*/ @NonNull List<RelPatternNode> ownedRelPatternNodes = _1.getOwnedRelPatternNodes();
+					final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedRelPatternNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelPatternNode, ownedRelPatternNodes);
 					//
 					for (Object value : BOXED_ownedRelPatternNodes.flatten().getElements()) {
 						accumulator.add(value);
 					}
 				}
-				/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_0 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
+				/*@Thrown*/ @NonNull Accumulator accumulator_0 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
 				@NonNull Iterator<Object> ITERATOR__1_0 = collect.iterator();
-				/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue select;
+				/*@NonInvalid*/ @NonNull SequenceValue select;
 				while (true) {
 					if (!ITERATOR__1_0.hasNext()) {
 						select = accumulator_0;
 						break;
 					}
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode _1_0 = (RelPatternNode)ITERATOR__1_0.next();
+					/*@NonInvalid*/ @NonNull RelPatternNode _1_0 = (@NonNull RelPatternNode)ITERATOR__1_0.next();
 					/**
 					 * isRoot
 					 */
@@ -279,52 +295,51 @@
 						accumulator_0.add(_1_0);
 					}
 				}
-				final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue expectedNodes = CollectionAsSetOperation.INSTANCE.evaluate(select);
+				final /*@NonInvalid*/ @NonNull SetValue expectedNodes = CollectionAsSetOperation.INSTANCE.evaluate(select);
 				@SuppressWarnings("null")
-				final /*@NonInvalid*/ java.util.@NonNull List<RelInvocationEdge> ownedRelInvocationEdges = this.getOwnedRelInvocationEdges();
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedRelInvocationEdges = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelInvocationEdge, ownedRelInvocationEdges);
-				/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_1 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
+				final /*@NonInvalid*/ @NonNull List<RelInvocationEdge> ownedRelInvocationEdges = this.getOwnedRelInvocationEdges();
+				final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedRelInvocationEdges = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelInvocationEdge, ownedRelInvocationEdges);
+				/*@Thrown*/ @NonNull Accumulator accumulator_1 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_RelPatternNode);
 				@NonNull Iterator<Object> ITERATOR__1_1 = BOXED_ownedRelInvocationEdges.iterator();
-				/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue collect_0;
+				/*@NonInvalid*/ @NonNull SequenceValue collect_0;
 				while (true) {
 					if (!ITERATOR__1_1.hasNext()) {
 						collect_0 = accumulator_1;
 						break;
 					}
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelInvocationEdge _1_1 = (RelInvocationEdge)ITERATOR__1_1.next();
+					/*@NonInvalid*/ @NonNull RelInvocationEdge _1_1 = (@NonNull RelInvocationEdge)ITERATOR__1_1.next();
 					/**
 					 * referredRelPatternNode
 					 */
 					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode referredRelPatternNode = _1_1.getReferredRelPatternNode();
+					final /*@NonInvalid*/ @NonNull RelPatternNode referredRelPatternNode = _1_1.getReferredRelPatternNode();
 					//
 					accumulator_1.add(referredRelPatternNode);
 				}
-				final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue actualNodes = CollectionAsSetOperation.INSTANCE.evaluate(collect_0);
-				final /*@Thrown*/ boolean status = expectedNodes.equals(actualNodes);
-				/*@Thrown*/ java.lang.@NonNull Object symbol_1;
+				final /*@NonInvalid*/ @NonNull SetValue actualNodes = CollectionAsSetOperation.INSTANCE.evaluate(collect_0);
+				final /*@NonInvalid*/ boolean status = expectedNodes.equals(actualNodes);
+				/*@NonInvalid*/ @NonNull Object symbol_1;
 				if (status) {
 					symbol_1 = ValueUtil.TRUE_VALUE;
 				}
 				else {
-					final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue size_0 = CollectionSizeOperation.INSTANCE.evaluate(expectedNodes);
-					final /*@Thrown*/ java.lang.@NonNull String toString_0 = OclAnyToStringOperation.INSTANCE.evaluate(size_0);
-					final /*@Thrown*/ java.lang.@NonNull String sum = StringConcatOperation.INSTANCE.evaluate(UMLXTables.STR_RelInvocationNode_c_c_CompatibleEdges_32, toString_0);
-					final /*@Thrown*/ java.lang.@NonNull String sum_0 = StringConcatOperation.INSTANCE.evaluate(sum, UMLXTables.STR_quot);
-					final /*@Thrown*/ java.lang.@NonNull String sum_1 = StringConcatOperation.INSTANCE.evaluate(sum_0, toString_0);
-					final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull TupleValue symbol_0 = ValueUtil.createTupleOfEach(UMLXTables.TUPLid_, sum_1, status);
+					final /*@NonInvalid*/ @NonNull IntegerValue size_0 = CollectionSizeOperation.INSTANCE.evaluate(expectedNodes);
+					final /*@NonInvalid*/ @NonNull String toString_0 = OclAnyToStringOperation.INSTANCE.evaluate(size_0);
+					final /*@NonInvalid*/ @NonNull String sum = StringConcatOperation.INSTANCE.evaluate(UMLXTables.STR_RelInvocationNode_c_c_CompatibleEdges_32, toString_0);
+					final /*@NonInvalid*/ @NonNull String sum_0 = StringConcatOperation.INSTANCE.evaluate(sum, UMLXTables.STR_quot);
+					final /*@NonInvalid*/ @NonNull String sum_1 = StringConcatOperation.INSTANCE.evaluate(sum_0, toString_0);
+					final /*@NonInvalid*/ @NonNull TupleValue symbol_0 = ValueUtil.createTupleOfEach(UMLXTables.TUPLid_, sum_1, status);
 					symbol_1 = symbol_0;
 				}
-				CAUGHT_symbol_1 = symbol_1;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelInvocationNode_c_c_CompatibleEdges, this, (Object)null, diagnostics, context, (Object)null, severity_0, symbol_1, UMLXTables.INT_0).booleanValue();
+				symbol_2 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_symbol_1 = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelInvocationNode_c_c_CompatibleEdges, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_symbol_1, UMLXTables.INT_0).booleanValue();
-			symbol_2 = logDiagnostic;
+			return Boolean.TRUE == symbol_2;
 		}
-		return Boolean.TRUE == symbol_2;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelInvocationNode::CompatibleEdges", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -334,7 +349,7 @@
 	 */
 	@Override
 	public RelDiagram getOwningRelDiagram() {
-		if (eContainerFeatureID() != UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM) return null;
+		if (eContainerFeatureID() != (RelNodeImpl.REL_NODE_FEATURE_COUNT + 1)) return null;
 		return (RelDiagram)eInternalContainer();
 	}
 
@@ -344,7 +359,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningRelDiagram(RelDiagram newOwningRelDiagram, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningRelDiagram, UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningRelDiagram, RelNodeImpl.REL_NODE_FEATURE_COUNT + 1, msgs);
 		return msgs;
 	}
 
@@ -355,19 +370,19 @@
 	 */
 	@Override
 	public void setOwningRelDiagram(RelDiagram newOwningRelDiagram) {
-		if (newOwningRelDiagram != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM && newOwningRelDiagram != null)) {
+		if (newOwningRelDiagram != eInternalContainer() || (eContainerFeatureID() != (RelNodeImpl.REL_NODE_FEATURE_COUNT + 1) && newOwningRelDiagram != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningRelDiagram))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningRelDiagram != null)
-				msgs = ((InternalEObject)newOwningRelDiagram).eInverseAdd(this, UMLXPackage.REL_DIAGRAM__OWNED_REL_INVOCATION_NODES, RelDiagram.class, msgs);
+				msgs = ((InternalEObject)newOwningRelDiagram).eInverseAdd(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3, RelDiagram.class, msgs);
 			msgs = basicSetOwningRelDiagram(newOwningRelDiagram, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM, newOwningRelDiagram, newOwningRelDiagram));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 1, newOwningRelDiagram, newOwningRelDiagram));
 	}
 
 	/**
@@ -378,7 +393,7 @@
 	@Override
 	public EList<RelInvocationEdge> getOwnedRelInvocationEdges() {
 		if (ownedRelInvocationEdges == null) {
-			ownedRelInvocationEdges = new EObjectContainmentWithInverseEList<RelInvocationEdge>(RelInvocationEdge.class, this, UMLXPackage.REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES, UMLXPackage.REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE);
+			ownedRelInvocationEdges = new EObjectContainmentWithInverseEList<RelInvocationEdge>(RelInvocationEdge.class, this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 2, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1);
 		}
 		return ownedRelInvocationEdges;
 	}
@@ -391,13 +406,13 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_NODE__IS_THEN:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				return isIsThen();
-			case UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				return getOwningRelDiagram();
-			case UMLXPackage.REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return getOwnedRelInvocationEdges();
-			case UMLXPackage.REL_INVOCATION_NODE__REFERRED_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				if (resolve) return getReferredRelDiagram();
 				return basicGetReferredRelDiagram();
 		}
@@ -413,17 +428,17 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_NODE__IS_THEN:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				setIsThen((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				setOwningRelDiagram((RelDiagram)newValue);
 				return;
-			case UMLXPackage.REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				getOwnedRelInvocationEdges().clear();
 				getOwnedRelInvocationEdges().addAll((Collection<? extends RelInvocationEdge>)newValue);
 				return;
-			case UMLXPackage.REL_INVOCATION_NODE__REFERRED_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				setReferredRelDiagram((RelDiagram)newValue);
 				return;
 		}
@@ -438,16 +453,16 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_NODE__IS_THEN:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				setIsThen(IS_THEN_EDEFAULT);
 				return;
-			case UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				setOwningRelDiagram((RelDiagram)null);
 				return;
-			case UMLXPackage.REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				getOwnedRelInvocationEdges().clear();
 				return;
-			case UMLXPackage.REL_INVOCATION_NODE__REFERRED_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				setReferredRelDiagram((RelDiagram)null);
 				return;
 		}
@@ -462,13 +477,13 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_NODE__IS_THEN:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				return isThen != IS_THEN_EDEFAULT;
-			case UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				return getOwningRelDiagram() != null;
-			case UMLXPackage.REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return ownedRelInvocationEdges != null && !ownedRelInvocationEdges.isEmpty();
-			case UMLXPackage.REL_INVOCATION_NODE__REFERRED_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				return referredRelDiagram != null;
 		}
 		return super.eIsSet(featureID);
@@ -490,7 +505,13 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (isThen: ");
+		result.append(isThen);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -502,11 +523,11 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningRelDiagram((RelDiagram)otherEnd, msgs);
-			case UMLXPackage.REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedRelInvocationEdges()).basicAdd(otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
@@ -520,9 +541,9 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				return basicSetOwningRelDiagram(null, msgs);
-			case UMLXPackage.REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return ((InternalEList<?>)getOwnedRelInvocationEdges()).basicRemove(otherEnd, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -536,8 +557,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.REL_INVOCATION_NODE__OWNING_REL_DIAGRAM:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.REL_DIAGRAM__OWNED_REL_INVOCATION_NODES, RelDiagram.class, msgs);
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
+				return eInternalContainer().eInverseRemove(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3, RelDiagram.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelNodeImpl.java
index e94780d..8f6c5c9 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelNodeImpl.java
@@ -24,6 +24,15 @@
  */
 public abstract class RelNodeImpl extends UMLXElementImpl implements RelNode {
 	/**
+	 * The number of structural features of the '<em>Rel Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int REL_NODE_FEATURE_COUNT = UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0;
+
+	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelPatternEdgeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelPatternEdgeImpl.java
index 8d1f4c5..81f7ea5 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelPatternEdgeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelPatternEdgeImpl.java
@@ -10,24 +10,27 @@
  */
 package org.eclipse.qvtd.umlx.impl;
 
+import java.util.List;
 import java.util.Map;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.StandardLibrary;
 import org.eclipse.ocl.pivot.evaluation.Executor;
+import org.eclipse.ocl.pivot.ids.IdResolver;
 import org.eclipse.ocl.pivot.ids.TypeId;
 import org.eclipse.ocl.pivot.internal.library.executor.ExecutorSingleIterationManager;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.AbstractBinaryOperation;
-import org.eclipse.ocl.pivot.library.LibraryIteration;
+import org.eclipse.ocl.pivot.library.LibraryIteration.LibraryIterationExtension;
 import org.eclipse.ocl.pivot.library.collection.CollectionIncludesOperation;
 import org.eclipse.ocl.pivot.library.logical.BooleanAndOperation;
 import org.eclipse.ocl.pivot.library.logical.BooleanImpliesOperation;
@@ -42,9 +45,11 @@
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
 import org.eclipse.ocl.pivot.oclstdlib.OCLstdlibTables;
-import org.eclipse.ocl.pivot.utilities.ClassUtil;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
+import org.eclipse.ocl.pivot.values.IntegerValue;
 import org.eclipse.ocl.pivot.values.InvalidValueException;
+import org.eclipse.ocl.pivot.values.OrderedSetValue;
 import org.eclipse.ocl.pivot.values.SetValue;
 import org.eclipse.qvtd.umlx.RelDomainNode;
 import org.eclipse.qvtd.umlx.RelPatternEdge;
@@ -72,6 +77,15 @@
  */
 public class RelPatternEdgeImpl extends RelEdgeImpl implements RelPatternEdge {
 	/**
+	 * The number of structural features of the '<em>Rel Pattern Edge</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int REL_PATTERN_EDGE_FEATURE_COUNT = RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 5;
+
+	/**
 	 * The cached value of the '{@link #getReferredEStructuralFeature() <em>Referred EStructural Feature</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -152,7 +166,7 @@
 			source = (RelPatternNode)eResolveProxy(oldSource);
 			if (source != oldSource) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.REL_PATTERN_EDGE__SOURCE, oldSource, source));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2, oldSource, source));
 			}
 		}
 		return source;
@@ -176,7 +190,7 @@
 		RelPatternNode oldSource = source;
 		source = newSource;
 		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_EDGE__SOURCE, oldSource, newSource);
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2, oldSource, newSource);
 			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
@@ -192,14 +206,14 @@
 		if (newSource != source) {
 			NotificationChain msgs = null;
 			if (source != null)
-				msgs = ((InternalEObject)source).eInverseRemove(this, UMLXPackage.REL_PATTERN_NODE__OUTGOING, RelPatternNode.class, msgs);
+				msgs = ((InternalEObject)source).eInverseRemove(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 12, RelPatternNode.class, msgs);
 			if (newSource != null)
-				msgs = ((InternalEObject)newSource).eInverseAdd(this, UMLXPackage.REL_PATTERN_NODE__OUTGOING, RelPatternNode.class, msgs);
+				msgs = ((InternalEObject)newSource).eInverseAdd(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 12, RelPatternNode.class, msgs);
 			msgs = basicSetSource(newSource, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_EDGE__SOURCE, newSource, newSource));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2, newSource, newSource));
 	}
 
 	/**
@@ -222,7 +236,7 @@
 		int oldSourceIndex = sourceIndex;
 		sourceIndex = newSourceIndex;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_EDGE__SOURCE_INDEX, oldSourceIndex, sourceIndex));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 3, oldSourceIndex, sourceIndex));
 	}
 
 	/**
@@ -232,7 +246,7 @@
 	 */
 	@Override
 	public RelDomainNode getOwningRelDomainNode() {
-		if (eContainerFeatureID() != UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE) return null;
+		if (eContainerFeatureID() != (RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0)) return null;
 		return (RelDomainNode)eInternalContainer();
 	}
 
@@ -242,7 +256,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningRelDomainNode(RelDomainNode newOwningRelDomainNode, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningRelDomainNode, UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningRelDomainNode, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0, msgs);
 		return msgs;
 	}
 
@@ -253,19 +267,19 @@
 	 */
 	@Override
 	public void setOwningRelDomainNode(RelDomainNode newOwningRelDomainNode) {
-		if (newOwningRelDomainNode != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE && newOwningRelDomainNode != null)) {
+		if (newOwningRelDomainNode != eInternalContainer() || (eContainerFeatureID() != (RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0) && newOwningRelDomainNode != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningRelDomainNode))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningRelDomainNode != null)
-				msgs = ((InternalEObject)newOwningRelDomainNode).eInverseAdd(this, UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES, RelDomainNode.class, msgs);
+				msgs = ((InternalEObject)newOwningRelDomainNode).eInverseAdd(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 1, RelDomainNode.class, msgs);
 			msgs = basicSetOwningRelDomainNode(newOwningRelDomainNode, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE, newOwningRelDomainNode, newOwningRelDomainNode));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0, newOwningRelDomainNode, newOwningRelDomainNode));
 	}
 
 	/**
@@ -280,7 +294,7 @@
 			referredEStructuralFeature = (EStructuralFeature)eResolveProxy(oldReferredEStructuralFeature);
 			if (referredEStructuralFeature != oldReferredEStructuralFeature) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.REL_PATTERN_EDGE__REFERRED_ESTRUCTURAL_FEATURE, oldReferredEStructuralFeature, referredEStructuralFeature));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1, oldReferredEStructuralFeature, referredEStructuralFeature));
 			}
 		}
 		return referredEStructuralFeature;
@@ -305,7 +319,7 @@
 		EStructuralFeature oldReferredEStructuralFeature = referredEStructuralFeature;
 		referredEStructuralFeature = newReferredEStructuralFeature;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_EDGE__REFERRED_ESTRUCTURAL_FEATURE, oldReferredEStructuralFeature, referredEStructuralFeature));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1, oldReferredEStructuralFeature, referredEStructuralFeature));
 	}
 
 	/**
@@ -320,7 +334,7 @@
 			target = (RelPatternNode)eResolveProxy(oldTarget);
 			if (target != oldTarget) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.REL_PATTERN_EDGE__TARGET, oldTarget, target));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4, oldTarget, target));
 			}
 		}
 		return target;
@@ -344,7 +358,7 @@
 		RelPatternNode oldTarget = target;
 		target = newTarget;
 		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_EDGE__TARGET, oldTarget, newTarget);
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4, oldTarget, newTarget);
 			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
@@ -360,14 +374,14 @@
 		if (newTarget != target) {
 			NotificationChain msgs = null;
 			if (target != null)
-				msgs = ((InternalEObject)target).eInverseRemove(this, UMLXPackage.REL_PATTERN_NODE__INCOMING, RelPatternNode.class, msgs);
+				msgs = ((InternalEObject)target).eInverseRemove(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 7, RelPatternNode.class, msgs);
 			if (newTarget != null)
-				msgs = ((InternalEObject)newTarget).eInverseAdd(this, UMLXPackage.REL_PATTERN_NODE__INCOMING, RelPatternNode.class, msgs);
+				msgs = ((InternalEObject)newTarget).eInverseAdd(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 7, RelPatternNode.class, msgs);
 			msgs = basicSetTarget(newTarget, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_EDGE__TARGET, newTarget, newTarget));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4, newTarget, newTarget));
 	}
 
 	/**
@@ -377,56 +391,61 @@
 	 */
 	@Override
 	public boolean validateSourceIsEClass(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv SourceIsEClass:
-		 *   let severity : Integer[1] = 'RelPatternEdge::SourceIsEClass'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let
-		 *         result : Boolean[?] = not source.isExpression() implies
-		 *         source.referredEClassifier.oclIsKindOf(ecore::EClassifier)
-		 *       in
-		 *         'RelPatternEdge::SourceIsEClass'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_SourceIsEClass);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @Nullable Object CAUGHT_result;
-			try {
-				@SuppressWarnings("null")
-				final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode source = this.getSource();
-				final /*@NonInvalid*/ boolean isExpression = source.isExpression();
-				final /*@NonInvalid*/ java.lang.@Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-				/*@Caught*/ @NonNull Object CAUGHT_oclIsKindOf;
+		try {
+			/**
+			 *
+			 * inv SourceIsEClass:
+			 *   let severity : Integer[1] = 'RelPatternEdge::SourceIsEClass'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let
+			 *         result : Boolean[?] = not source.isExpression() implies
+			 *         source.referredEClassifier.oclIsKindOf(ecore::EClassifier)
+			 *       in
+			 *         'RelPatternEdge::SourceIsEClass'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_SourceIsEClass);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @Nullable Object CAUGHT_result;
 				try {
-					final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClassifier = idResolver.getClass(UMLXTables.CLSSid_EClassifier, null);
-					final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = source.getReferredEClassifier();
-					final /*@Thrown*/ boolean oclIsKindOf = OclAnyOclIsKindOfOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClassifier).booleanValue();
-					CAUGHT_oclIsKindOf = oclIsKindOf;
+					@SuppressWarnings("null")
+					final /*@NonInvalid*/ @NonNull RelPatternNode source = this.getSource();
+					final /*@NonInvalid*/ boolean isExpression = source.isExpression();
+					final /*@NonInvalid*/ @Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+					/*@Caught*/ @NonNull Object CAUGHT_oclIsKindOf;
+					try {
+						final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClassifier = idResolver.getClass(UMLXTables.CLSSid_EClassifier, null);
+						final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = source.getReferredEClassifier();
+						final /*@Thrown*/ boolean oclIsKindOf = OclAnyOclIsKindOfOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClassifier).booleanValue();
+						CAUGHT_oclIsKindOf = oclIsKindOf;
+					}
+					catch (Exception e) {
+						CAUGHT_oclIsKindOf = ValueUtil.createInvalidValue(e);
+					}
+					final /*@Thrown*/ @Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(not, CAUGHT_oclIsKindOf);
+					CAUGHT_result = result;
 				}
 				catch (Exception e) {
-					CAUGHT_oclIsKindOf = ValueUtil.createInvalidValue(e);
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
 				}
-				final /*@Thrown*/ java.lang.@Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(not, CAUGHT_oclIsKindOf);
-				CAUGHT_result = result;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_SourceIsEClass, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_SourceIsEClass, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternEdge::SourceIsEClass", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -436,36 +455,41 @@
 	 */
 	@Override
 	public boolean validateSourceIsClassNode(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv SourceIsClassNode:
-		 *   let
-		 *     severity : Integer[1] = 'RelPatternEdge::SourceIsClassNode'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[?] = not source.isExpression()
-		 *       in
-		 *         'RelPatternEdge::SourceIsClassNode'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_SourceIsClassNode);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv SourceIsClassNode:
+			 *   let
+			 *     severity : Integer[1] = 'RelPatternEdge::SourceIsClassNode'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[?] = not source.isExpression()
+			 *       in
+			 *         'RelPatternEdge::SourceIsClassNode'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_SourceIsClassNode);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				@SuppressWarnings("null")
+				final /*@NonInvalid*/ @NonNull RelPatternNode source = this.getSource();
+				final /*@NonInvalid*/ boolean isExpression = source.isExpression();
+				final /*@NonInvalid*/ @Nullable Boolean result = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_SourceIsClassNode, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			@SuppressWarnings("null")
-			final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode source = this.getSource();
-			final /*@NonInvalid*/ boolean isExpression = source.isExpression();
-			final /*@NonInvalid*/ java.lang.@Nullable Boolean result = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_SourceIsClassNode, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternEdge::SourceIsClassNode", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -475,89 +499,94 @@
 	 */
 	@Override
 	public boolean validateCompatibleEAttributePropertyTarget(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv CompatibleEAttributePropertyTarget:
-		 *   let
-		 *     severity : Integer[1] = 'RelPatternEdge::CompatibleEAttributePropertyTarget'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[?] = referredEStructuralFeature <> null and
-		 *         referredEStructuralFeature.oclIsKindOf(ecore::EAttribute) and
-		 *         not target.isExpression() implies referredEStructuralFeature.eType = target.referredEClassifier
-		 *       in
-		 *         'RelPatternEdge::CompatibleEAttributePropertyTarget'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleEAttributePropertyTarget);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @Nullable Object CAUGHT_result;
-			try {
-				/*@Caught*/ @Nullable Object CAUGHT_and_0;
+		try {
+			/**
+			 *
+			 * inv CompatibleEAttributePropertyTarget:
+			 *   let
+			 *     severity : Integer[1] = 'RelPatternEdge::CompatibleEAttributePropertyTarget'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[?] = referredEStructuralFeature <> null and
+			 *         referredEStructuralFeature.oclIsKindOf(ecore::EAttribute) and
+			 *         not target.isExpression() implies referredEStructuralFeature.eType = target.referredEClassifier
+			 *       in
+			 *         'RelPatternEdge::CompatibleEAttributePropertyTarget'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleEAttributePropertyTarget);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @Nullable Object CAUGHT_result;
 				try {
-					/*@Caught*/ @NonNull Object CAUGHT_and;
+					/*@Caught*/ @Nullable Object CAUGHT_and_0;
 					try {
-						final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EStructuralFeature referredEStructuralFeature_0 = this.getReferredEStructuralFeature();
-						final /*@NonInvalid*/ boolean ne = referredEStructuralFeature_0 != null;
-						/*@Thrown*/ boolean and;
-						if (ne) {
-							final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EAttribute = idResolver.getClass(UMLXTables.CLSSid_EAttribute, null);
-							final /*@Thrown*/ boolean oclIsKindOf = OclAnyOclIsKindOfOperation.INSTANCE.evaluate(executor, referredEStructuralFeature_0, TYP_ecore_c_c_EAttribute).booleanValue();
-							and = oclIsKindOf;
+						/*@Caught*/ @NonNull Object CAUGHT_and;
+						try {
+							final /*@NonInvalid*/ @Nullable EStructuralFeature referredEStructuralFeature_0 = this.getReferredEStructuralFeature();
+							final /*@NonInvalid*/ boolean ne = referredEStructuralFeature_0 != null;
+							/*@Thrown*/ boolean and;
+							if (ne) {
+								final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EAttribute = idResolver.getClass(UMLXTables.CLSSid_EAttribute, null);
+								final /*@Thrown*/ boolean oclIsKindOf = OclAnyOclIsKindOfOperation.INSTANCE.evaluate(executor, referredEStructuralFeature_0, TYP_ecore_c_c_EAttribute).booleanValue();
+								and = oclIsKindOf;
+							}
+							else {
+								and = ValueUtil.FALSE_VALUE;
+							}
+							CAUGHT_and = and;
 						}
-						else {
-							and = ValueUtil.FALSE_VALUE;
+						catch (Exception e) {
+							CAUGHT_and = ValueUtil.createInvalidValue(e);
 						}
-						CAUGHT_and = and;
+						@SuppressWarnings("null")
+						final /*@NonInvalid*/ @NonNull RelPatternNode target = this.getTarget();
+						final /*@NonInvalid*/ boolean isExpression = target.isExpression();
+						final /*@NonInvalid*/ @Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+						final /*@Thrown*/ @Nullable Boolean and_0 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and, not);
+						CAUGHT_and_0 = and_0;
 					}
 					catch (Exception e) {
-						CAUGHT_and = ValueUtil.createInvalidValue(e);
+						CAUGHT_and_0 = ValueUtil.createInvalidValue(e);
 					}
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode target = this.getTarget();
-					final /*@NonInvalid*/ boolean isExpression = target.isExpression();
-					final /*@NonInvalid*/ java.lang.@Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-					final /*@Thrown*/ java.lang.@Nullable Boolean and_0 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and, not);
-					CAUGHT_and_0 = and_0;
+					/*@Caught*/ @NonNull Object CAUGHT_eq;
+					try {
+						final /*@NonInvalid*/ @Nullable EStructuralFeature referredEStructuralFeature_1 = this.getReferredEStructuralFeature();
+						if (referredEStructuralFeature_1 == null) {
+							throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::ETypedElement::eType\'");
+						}
+						final /*@Thrown*/ @Nullable EClassifier eType = referredEStructuralFeature_1.getEType();
+						@SuppressWarnings("null")
+						final /*@NonInvalid*/ @NonNull RelPatternNode target_0 = this.getTarget();
+						final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = target_0.getReferredEClassifier();
+						final /*@Thrown*/ boolean eq = (eType != null) ? eType.equals(referredEClassifier) : (referredEClassifier == null);
+						CAUGHT_eq = eq;
+					}
+					catch (Exception e) {
+						CAUGHT_eq = ValueUtil.createInvalidValue(e);
+					}
+					final /*@Thrown*/ @Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(CAUGHT_and_0, CAUGHT_eq);
+					CAUGHT_result = result;
 				}
 				catch (Exception e) {
-					CAUGHT_and_0 = ValueUtil.createInvalidValue(e);
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
 				}
-				/*@Caught*/ @NonNull Object CAUGHT_eq;
-				try {
-					final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EStructuralFeature referredEStructuralFeature_1 = this.getReferredEStructuralFeature();
-					if (referredEStructuralFeature_1 == null) {
-						throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::ETypedElement::eType\'");
-					}
-					final /*@Thrown*/ org.eclipse.emf.ecore.@Nullable EClassifier eType = referredEStructuralFeature_1.getEType();
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode target_0 = this.getTarget();
-					final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = target_0.getReferredEClassifier();
-					final /*@Thrown*/ boolean eq = (eType != null) ? eType.equals(referredEClassifier) : (referredEClassifier == null);
-					CAUGHT_eq = eq;
-				}
-				catch (Exception e) {
-					CAUGHT_eq = ValueUtil.createInvalidValue(e);
-				}
-				final /*@Thrown*/ java.lang.@Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(CAUGHT_and_0, CAUGHT_eq);
-				CAUGHT_result = result;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleEAttributePropertyTarget, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleEAttributePropertyTarget, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternEdge::CompatibleEAttributePropertyTarget", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -567,38 +596,43 @@
 	 */
 	@Override
 	public boolean validateCompatibleSourceMultiplicity(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv CompatibleSourceMultiplicity:
-		 *   let
-		 *     severity : Integer[1] = 'RelPatternEdge::CompatibleSourceMultiplicity'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = referredEStructuralFeature = null = source.isMany
-		 *       in
-		 *         'RelPatternEdge::CompatibleSourceMultiplicity'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleSourceMultiplicity);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv CompatibleSourceMultiplicity:
+			 *   let
+			 *     severity : Integer[1] = 'RelPatternEdge::CompatibleSourceMultiplicity'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = referredEStructuralFeature = null = source.isMany
+			 *       in
+			 *         'RelPatternEdge::CompatibleSourceMultiplicity'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleSourceMultiplicity);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				final /*@NonInvalid*/ @Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
+				final /*@NonInvalid*/ boolean eq = referredEStructuralFeature == null;
+				@SuppressWarnings("null")
+				final /*@NonInvalid*/ @NonNull RelPatternNode source = this.getSource();
+				final /*@NonInvalid*/ boolean isMany = source.isIsMany();
+				final /*@NonInvalid*/ boolean result = eq == isMany;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleSourceMultiplicity, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
-			final /*@NonInvalid*/ boolean eq = referredEStructuralFeature == null;
-			@SuppressWarnings("null")
-			final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode source = this.getSource();
-			final /*@NonInvalid*/ boolean isMany = source.isIsMany();
-			final /*@NonInvalid*/ boolean result = eq == isMany;
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleSourceMultiplicity, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternEdge::CompatibleSourceMultiplicity", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -608,122 +642,129 @@
 	 */
 	@Override
 	public boolean validateCompatibleEReferencePropertyTarget(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv CompatibleEReferencePropertyTarget:
-		 *   let
-		 *     severity : Integer[1] = 'RelPatternEdge::CompatibleEReferencePropertyTarget'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[?] = referredEStructuralFeature <> null and
-		 *         referredEStructuralFeature.oclIsKindOf(ecore::EReference) and
-		 *         not target.isExpression() implies
-		 *         let
-		 *           sourceEClass : ecore::EClass[1] = target.referredEClassifier.oclAsType(ecore::EClass)
-		 *         in
-		 *           sourceEClass->closure(eSuperTypes)
-		 *           ->includes(referredEStructuralFeature.eType)
-		 *       in
-		 *         'RelPatternEdge::CompatibleEReferencePropertyTarget'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull StandardLibrary standardLibrary = idResolver.getStandardLibrary();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleEReferencePropertyTarget);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_1;
-		if (le) {
-			symbol_1 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @Nullable Object CAUGHT_result;
-			try {
-				/*@Caught*/ @Nullable Object CAUGHT_and_0;
+		try {
+			/**
+			 *
+			 * inv CompatibleEReferencePropertyTarget:
+			 *   let
+			 *     severity : Integer[1] = 'RelPatternEdge::CompatibleEReferencePropertyTarget'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[?] = referredEStructuralFeature <> null and
+			 *         referredEStructuralFeature.oclIsKindOf(ecore::EReference) and
+			 *         not target.isExpression() implies
+			 *         let
+			 *           sourceEClass : ecore::EClass[1] = target.referredEClassifier.oclAsType(ecore::EClass)
+			 *         in
+			 *           sourceEClass->closure(eSuperTypes)
+			 *           ->includes(referredEStructuralFeature.eType)
+			 *       in
+			 *         'RelPatternEdge::CompatibleEReferencePropertyTarget'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull StandardLibrary standardLibrary = idResolver.getStandardLibrary();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleEReferencePropertyTarget);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_1;
+			if (le) {
+				symbol_1 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @Nullable Object CAUGHT_result;
 				try {
-					/*@Caught*/ @NonNull Object CAUGHT_and;
+					/*@Caught*/ @Nullable Object CAUGHT_and_0;
 					try {
-						final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EStructuralFeature referredEStructuralFeature_0 = this.getReferredEStructuralFeature();
-						final /*@NonInvalid*/ boolean ne = referredEStructuralFeature_0 != null;
-						/*@Thrown*/ boolean and;
-						if (ne) {
-							final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EReference = idResolver.getClass(UMLXTables.CLSSid_EReference, null);
-							final /*@Thrown*/ boolean oclIsKindOf = OclAnyOclIsKindOfOperation.INSTANCE.evaluate(executor, referredEStructuralFeature_0, TYP_ecore_c_c_EReference).booleanValue();
-							and = oclIsKindOf;
+						/*@Caught*/ @NonNull Object CAUGHT_and;
+						try {
+							final /*@NonInvalid*/ @Nullable EStructuralFeature referredEStructuralFeature_0 = this.getReferredEStructuralFeature();
+							final /*@NonInvalid*/ boolean ne = referredEStructuralFeature_0 != null;
+							/*@Thrown*/ boolean and;
+							if (ne) {
+								final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EReference = idResolver.getClass(UMLXTables.CLSSid_EReference, null);
+								final /*@Thrown*/ boolean oclIsKindOf = OclAnyOclIsKindOfOperation.INSTANCE.evaluate(executor, referredEStructuralFeature_0, TYP_ecore_c_c_EReference).booleanValue();
+								and = oclIsKindOf;
+							}
+							else {
+								and = ValueUtil.FALSE_VALUE;
+							}
+							CAUGHT_and = and;
 						}
-						else {
-							and = ValueUtil.FALSE_VALUE;
+						catch (Exception e) {
+							CAUGHT_and = ValueUtil.createInvalidValue(e);
 						}
-						CAUGHT_and = and;
+						@SuppressWarnings("null")
+						final /*@NonInvalid*/ @NonNull RelPatternNode target = this.getTarget();
+						final /*@NonInvalid*/ boolean isExpression = target.isExpression();
+						final /*@NonInvalid*/ @Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+						final /*@Thrown*/ @Nullable Boolean and_0 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and, not);
+						CAUGHT_and_0 = and_0;
 					}
 					catch (Exception e) {
-						CAUGHT_and = ValueUtil.createInvalidValue(e);
+						CAUGHT_and_0 = ValueUtil.createInvalidValue(e);
 					}
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode target = this.getTarget();
-					final /*@NonInvalid*/ boolean isExpression = target.isExpression();
-					final /*@NonInvalid*/ java.lang.@Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-					final /*@Thrown*/ java.lang.@Nullable Boolean and_0 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and, not);
-					CAUGHT_and_0 = and_0;
-				}
-				catch (Exception e) {
-					CAUGHT_and_0 = ValueUtil.createInvalidValue(e);
-				}
-				/*@Caught*/ @NonNull Object CAUGHT_includes;
-				try {
-					final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_0 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode target_0 = this.getTarget();
-					final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = target_0.getReferredEClassifier();
-					final /*@Thrown*/ org.eclipse.emf.ecore.@NonNull EClass sourceEClass = ClassUtil.nonNullState((EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClass_0));
-					final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue oclAsSet = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, sourceEClass);
-					final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_0 = executor.getStaticTypeOf(oclAsSet);
-					final LibraryIteration.@org.eclipse.jdt.annotation.NonNull LibraryIterationExtension IMPL_closure_0 = (LibraryIteration.LibraryIterationExtension)TYPE_closure_0.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
-					final @NonNull Object ACC_closure_0 = IMPL_closure_0.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
-					/**
-					 * Implementation of the iterator body.
-					 */
-					final @NonNull AbstractBinaryOperation BODY_closure_0 = new AbstractBinaryOperation() {
+					/*@Caught*/ @NonNull Object CAUGHT_includes;
+					try {
+						final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_0 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
+						@SuppressWarnings("null")
+						final /*@NonInvalid*/ @NonNull RelPatternNode target_0 = this.getTarget();
+						final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = target_0.getReferredEClassifier();
+						@SuppressWarnings("null")
+						final /*@Thrown*/ @NonNull EClass sourceEClass = (@NonNull EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClass_0);
+						final /*@Thrown*/ @NonNull SetValue oclAsSet = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, sourceEClass);
+						final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_0 = executor.getStaticTypeOfValue(null, oclAsSet);
+						final @NonNull LibraryIterationExtension IMPL_closure_0 = (LibraryIterationExtension)TYPE_closure_0.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
+						final @NonNull Object ACC_closure_0 = IMPL_closure_0.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
 						/**
-						 * eSuperTypes
+						 * Implementation of the iterator body.
 						 */
-						@Override
-						public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet, final /*@NonInvalid*/ java.lang.@Nullable Object _1) {
-							final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClass symbol_0 = (EClass)_1;
-							if (symbol_0 == null) {
-								throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
+						final @NonNull AbstractBinaryOperation BODY_closure_0 = new AbstractBinaryOperation() {
+							/**
+							 * eSuperTypes
+							 */
+							@Override
+							public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet, final /*@NonInvalid*/ @Nullable Object _1) {
+								final /*@NonInvalid*/ @Nullable EClass symbol_0 = (EClass)_1;
+								if (symbol_0 == null) {
+									throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
+								}
+								@SuppressWarnings("null")
+								final /*@Thrown*/ @NonNull List<EClass> eSuperTypes = symbol_0.getESuperTypes();
+								final /*@Thrown*/ @NonNull OrderedSetValue BOXED_eSuperTypes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes);
+								return BOXED_eSuperTypes;
 							}
-							@SuppressWarnings("null")
-							final /*@Thrown*/ java.util.@NonNull List<EClass> eSuperTypes = symbol_0.getESuperTypes();
-							final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_eSuperTypes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes);
-							return BOXED_eSuperTypes;
+						};
+						final @NonNull ExecutorSingleIterationManager MGR_closure_0 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_0, oclAsSet, ACC_closure_0);
+						@SuppressWarnings("null")
+						final /*@Thrown*/ @NonNull SetValue closure = (@NonNull SetValue)IMPL_closure_0.evaluateIteration(MGR_closure_0);
+						final /*@NonInvalid*/ @Nullable EStructuralFeature referredEStructuralFeature_1 = this.getReferredEStructuralFeature();
+						if (referredEStructuralFeature_1 == null) {
+							throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::ETypedElement::eType\'");
 						}
-					};
-					final @NonNull  ExecutorSingleIterationManager MGR_closure_0 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_0, oclAsSet, ACC_closure_0);
-					final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue closure = ClassUtil.nonNullState((SetValue)IMPL_closure_0.evaluateIteration(MGR_closure_0));
-					final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EStructuralFeature referredEStructuralFeature_1 = this.getReferredEStructuralFeature();
-					if (referredEStructuralFeature_1 == null) {
-						throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::ETypedElement::eType\'");
+						final /*@Thrown*/ @Nullable EClassifier eType = referredEStructuralFeature_1.getEType();
+						final /*@Thrown*/ boolean includes = CollectionIncludesOperation.INSTANCE.evaluate(closure, eType).booleanValue();
+						CAUGHT_includes = includes;
 					}
-					final /*@Thrown*/ org.eclipse.emf.ecore.@Nullable EClassifier eType = referredEStructuralFeature_1.getEType();
-					final /*@Thrown*/ boolean includes = CollectionIncludesOperation.INSTANCE.evaluate(closure, eType).booleanValue();
-					CAUGHT_includes = includes;
+					catch (Exception e) {
+						CAUGHT_includes = ValueUtil.createInvalidValue(e);
+					}
+					final /*@Thrown*/ @Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(CAUGHT_and_0, CAUGHT_includes);
+					CAUGHT_result = result;
 				}
 				catch (Exception e) {
-					CAUGHT_includes = ValueUtil.createInvalidValue(e);
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
 				}
-				final /*@Thrown*/ java.lang.@Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(CAUGHT_and_0, CAUGHT_includes);
-				CAUGHT_result = result;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleEReferencePropertyTarget, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_1 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleEReferencePropertyTarget, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_1 = logDiagnostic;
+			return Boolean.TRUE == symbol_1;
 		}
-		return Boolean.TRUE == symbol_1;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternEdge::CompatibleEReferencePropertyTarget", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -733,88 +774,95 @@
 	 */
 	@Override
 	public boolean validateCompatiblePropertySource(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv CompatiblePropertySource:
-		 *   let
-		 *     severity : Integer[1] = 'RelPatternEdge::CompatiblePropertySource'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[?] = referredEStructuralFeature <> null implies
-		 *         source.referredEClassifier.oclAsType(ecore::EClass)
-		 *         ->closure(eSuperTypes)
-		 *         ->includes(referredEStructuralFeature.eContainingClass)
-		 *       in
-		 *         'RelPatternEdge::CompatiblePropertySource'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull StandardLibrary standardLibrary = idResolver.getStandardLibrary();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatiblePropertySource);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_1;
-		if (le) {
-			symbol_1 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_result;
-			try {
-				final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
-				final /*@NonInvalid*/ boolean ne = referredEStructuralFeature != null;
-				/*@Thrown*/ boolean result;
-				if (ne) {
-					final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode source = this.getSource();
-					final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = source.getReferredEClassifier();
-					final /*@Thrown*/ org.eclipse.emf.ecore.@NonNull EClass oclAsType = ClassUtil.nonNullState((EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClass));
-					final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue oclAsSet = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, oclAsType);
-					final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_0 = executor.getStaticTypeOf(oclAsSet);
-					final LibraryIteration.@org.eclipse.jdt.annotation.NonNull LibraryIterationExtension IMPL_closure_0 = (LibraryIteration.LibraryIterationExtension)TYPE_closure_0.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
-					final @NonNull Object ACC_closure_0 = IMPL_closure_0.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
-					/**
-					 * Implementation of the iterator body.
-					 */
-					final @NonNull AbstractBinaryOperation BODY_closure_0 = new AbstractBinaryOperation() {
+		try {
+			/**
+			 *
+			 * inv CompatiblePropertySource:
+			 *   let
+			 *     severity : Integer[1] = 'RelPatternEdge::CompatiblePropertySource'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[?] = referredEStructuralFeature <> null implies
+			 *         source.referredEClassifier.oclAsType(ecore::EClass)
+			 *         ->closure(eSuperTypes)
+			 *         ->includes(referredEStructuralFeature.eContainingClass)
+			 *       in
+			 *         'RelPatternEdge::CompatiblePropertySource'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull StandardLibrary standardLibrary = idResolver.getStandardLibrary();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatiblePropertySource);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_1;
+			if (le) {
+				symbol_1 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @NonNull Object CAUGHT_result;
+				try {
+					final /*@NonInvalid*/ @Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
+					final /*@NonInvalid*/ boolean ne = referredEStructuralFeature != null;
+					/*@Thrown*/ boolean result;
+					if (ne) {
+						final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
+						@SuppressWarnings("null")
+						final /*@NonInvalid*/ @NonNull RelPatternNode source = this.getSource();
+						final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = source.getReferredEClassifier();
+						@SuppressWarnings("null")
+						final /*@Thrown*/ @NonNull EClass oclAsType = (@NonNull EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClass);
+						final /*@Thrown*/ @NonNull SetValue oclAsSet = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, oclAsType);
+						final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_0 = executor.getStaticTypeOfValue(null, oclAsSet);
+						final @NonNull LibraryIterationExtension IMPL_closure_0 = (LibraryIterationExtension)TYPE_closure_0.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
+						final @NonNull Object ACC_closure_0 = IMPL_closure_0.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
 						/**
-						 * eSuperTypes
+						 * Implementation of the iterator body.
 						 */
-						@Override
-						public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet, final /*@NonInvalid*/ java.lang.@Nullable Object _1) {
-							final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClass symbol_0 = (EClass)_1;
-							if (symbol_0 == null) {
-								throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
+						final @NonNull AbstractBinaryOperation BODY_closure_0 = new AbstractBinaryOperation() {
+							/**
+							 * eSuperTypes
+							 */
+							@Override
+							public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet, final /*@NonInvalid*/ @Nullable Object _1) {
+								final /*@NonInvalid*/ @Nullable EClass symbol_0 = (EClass)_1;
+								if (symbol_0 == null) {
+									throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
+								}
+								@SuppressWarnings("null")
+								final /*@Thrown*/ @NonNull List<EClass> eSuperTypes = symbol_0.getESuperTypes();
+								final /*@Thrown*/ @NonNull OrderedSetValue BOXED_eSuperTypes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes);
+								return BOXED_eSuperTypes;
 							}
-							@SuppressWarnings("null")
-							final /*@Thrown*/ java.util.@NonNull List<EClass> eSuperTypes = symbol_0.getESuperTypes();
-							final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_eSuperTypes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes);
-							return BOXED_eSuperTypes;
+						};
+						final @NonNull ExecutorSingleIterationManager MGR_closure_0 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_0, oclAsSet, ACC_closure_0);
+						@SuppressWarnings("null")
+						final /*@Thrown*/ @NonNull SetValue closure = (@NonNull SetValue)IMPL_closure_0.evaluateIteration(MGR_closure_0);
+						if (referredEStructuralFeature == null) {
+							throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EStructuralFeature::eContainingClass\'");
 						}
-					};
-					final @NonNull  ExecutorSingleIterationManager MGR_closure_0 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_0, oclAsSet, ACC_closure_0);
-					final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue closure = ClassUtil.nonNullState((SetValue)IMPL_closure_0.evaluateIteration(MGR_closure_0));
-					if (referredEStructuralFeature == null) {
-						throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EStructuralFeature::eContainingClass\'");
+						final /*@Thrown*/ @Nullable EClass eContainingClass = referredEStructuralFeature.getEContainingClass();
+						final /*@Thrown*/ boolean includes = CollectionIncludesOperation.INSTANCE.evaluate(closure, eContainingClass).booleanValue();
+						result = includes;
 					}
-					final /*@Thrown*/ org.eclipse.emf.ecore.@Nullable EClass eContainingClass = referredEStructuralFeature.getEContainingClass();
-					final /*@Thrown*/ boolean includes = CollectionIncludesOperation.INSTANCE.evaluate(closure, eContainingClass).booleanValue();
-					result = includes;
+					else {
+						result = ValueUtil.TRUE_VALUE;
+					}
+					CAUGHT_result = result;
 				}
-				else {
-					result = ValueUtil.TRUE_VALUE;
+				catch (Exception e) {
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
 				}
-				CAUGHT_result = result;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatiblePropertySource, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_1 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatiblePropertySource, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_1 = logDiagnostic;
+			return Boolean.TRUE == symbol_1;
 		}
-		return Boolean.TRUE == symbol_1;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternEdge::CompatiblePropertySource", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -824,38 +872,43 @@
 	 */
 	@Override
 	public boolean validateCompatibleSourceIndex(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv CompatibleSourceIndex:
-		 *   let
-		 *     severity : Integer[1] = 'RelPatternEdge::CompatibleSourceIndex'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = referredEStructuralFeature <> null = sourceIndex = 0
-		 *       in
-		 *         'RelPatternEdge::CompatibleSourceIndex'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleSourceIndex);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv CompatibleSourceIndex:
+			 *   let
+			 *     severity : Integer[1] = 'RelPatternEdge::CompatibleSourceIndex'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = referredEStructuralFeature <> null = sourceIndex = 0
+			 *       in
+			 *         'RelPatternEdge::CompatibleSourceIndex'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleSourceIndex);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				final /*@NonInvalid*/ @Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
+				final /*@NonInvalid*/ boolean ne = referredEStructuralFeature != null;
+				final /*@NonInvalid*/ int sourceIndex = this.getSourceIndex();
+				final /*@NonInvalid*/ @NonNull IntegerValue BOXED_sourceIndex = ValueUtil.integerValueOf(sourceIndex);
+				final /*@NonInvalid*/ boolean eq = BOXED_sourceIndex.equals(UMLXTables.INT_0);
+				final /*@NonInvalid*/ boolean result = ne == eq;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleSourceIndex, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
-			final /*@NonInvalid*/ boolean ne = referredEStructuralFeature != null;
-			final /*@NonInvalid*/ int sourceIndex = this.getSourceIndex();
-			final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue BOXED_sourceIndex = ValueUtil.integerValueOf(sourceIndex);
-			final /*@NonInvalid*/ boolean eq = BOXED_sourceIndex.equals(UMLXTables.INT_0);
-			final /*@NonInvalid*/ boolean result = ne == eq;
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleSourceIndex, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternEdge::CompatibleSourceIndex", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -865,157 +918,164 @@
 	 */
 	@Override
 	public boolean validateCompatibleRestPropertyTarget(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv CompatibleRestPropertyTarget:
-		 *   let
-		 *     severity : Integer[1] = 'RelPatternEdge::CompatibleRestPropertyTarget'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[?] = referredEStructuralFeature = null and sourceIndex < 0 and
-		 *         not target.isExpression() implies
-		 *         let
-		 *           sourceEClass : ecore::EClass[1] = source.referredEClassifier.oclAsType(ecore::EClass)
-		 *         in
-		 *           let
-		 *             targetEClass : ecore::EClass[1] = target.referredEClassifier.oclAsType(ecore::EClass)
-		 *           in sourceEClass = targetEClass and source.isMany = target.isMany and source.isNullFree = target.isNullFree and source.isOrdered = target.isOrdered and source.isUnique = target.isUnique
-		 *       in
-		 *         'RelPatternEdge::CompatibleRestPropertyTarget'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleRestPropertyTarget);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @Nullable Object CAUGHT_result;
-			try {
-				final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
-				final /*@NonInvalid*/ boolean eq = referredEStructuralFeature == null;
-				/*@NonInvalid*/ boolean and;
-				if (eq) {
-					final /*@NonInvalid*/ int sourceIndex = this.getSourceIndex();
-					final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue BOXED_sourceIndex = ValueUtil.integerValueOf(sourceIndex);
-					final /*@NonInvalid*/ boolean lt = OclComparableLessThanOperation.INSTANCE.evaluate(executor, BOXED_sourceIndex, UMLXTables.INT_0).booleanValue();
-					and = lt;
-				}
-				else {
-					and = ValueUtil.FALSE_VALUE;
-				}
-				/*@NonInvalid*/ java.lang.@Nullable Boolean and_0;
-				if (and) {
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode target = this.getTarget();
-					final /*@NonInvalid*/ boolean isExpression = target.isExpression();
-					final /*@NonInvalid*/ java.lang.@Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-					and_0 = not;
-				}
-				else {
-					and_0 = ValueUtil.FALSE_VALUE;
-				}
-				/*@Caught*/ @Nullable Object CAUGHT_and_4;
+		try {
+			/**
+			 *
+			 * inv CompatibleRestPropertyTarget:
+			 *   let
+			 *     severity : Integer[1] = 'RelPatternEdge::CompatibleRestPropertyTarget'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[?] = referredEStructuralFeature = null and sourceIndex < 0 and
+			 *         not target.isExpression() implies
+			 *         let
+			 *           sourceEClass : ecore::EClass[1] = source.referredEClassifier.oclAsType(ecore::EClass)
+			 *         in
+			 *           let
+			 *             targetEClass : ecore::EClass[1] = target.referredEClassifier.oclAsType(ecore::EClass)
+			 *           in sourceEClass = targetEClass and source.isMany = target.isMany and source.isNullFree = target.isNullFree and source.isOrdered = target.isOrdered and source.isUnique = target.isUnique
+			 *       in
+			 *         'RelPatternEdge::CompatibleRestPropertyTarget'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleRestPropertyTarget);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @Nullable Object CAUGHT_result;
 				try {
-					/*@Caught*/ @NonNull Object CAUGHT_sourceEClass;
-					try {
-						final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_0 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
+					final /*@NonInvalid*/ @Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
+					final /*@NonInvalid*/ boolean eq = referredEStructuralFeature == null;
+					/*@NonInvalid*/ boolean and;
+					if (eq) {
+						final /*@NonInvalid*/ int sourceIndex = this.getSourceIndex();
+						final /*@NonInvalid*/ @NonNull IntegerValue BOXED_sourceIndex = ValueUtil.integerValueOf(sourceIndex);
+						final /*@NonInvalid*/ boolean lt = OclComparableLessThanOperation.INSTANCE.evaluate(executor, BOXED_sourceIndex, UMLXTables.INT_0).booleanValue();
+						and = lt;
+					}
+					else {
+						and = ValueUtil.FALSE_VALUE;
+					}
+					/*@NonInvalid*/ @Nullable Boolean and_0;
+					if (and) {
 						@SuppressWarnings("null")
-						final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode source = this.getSource();
-						final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = source.getReferredEClassifier();
-						final /*@Thrown*/ org.eclipse.emf.ecore.@NonNull EClass sourceEClass = ClassUtil.nonNullState((EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClass_0));
-						CAUGHT_sourceEClass = sourceEClass;
+						final /*@NonInvalid*/ @NonNull RelPatternNode target = this.getTarget();
+						final /*@NonInvalid*/ boolean isExpression = target.isExpression();
+						final /*@NonInvalid*/ @Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+						and_0 = not;
 					}
-					catch (Exception e) {
-						CAUGHT_sourceEClass = ValueUtil.createInvalidValue(e);
+					else {
+						and_0 = ValueUtil.FALSE_VALUE;
 					}
-					/*@Caught*/ @NonNull Object CAUGHT_targetEClass;
+					/*@Caught*/ @Nullable Object CAUGHT_and_4;
 					try {
-						final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_1 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
-						@SuppressWarnings("null")
-						final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode target_0 = this.getTarget();
-						final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier_0 = target_0.getReferredEClassifier();
-						final /*@Thrown*/ org.eclipse.emf.ecore.@NonNull EClass targetEClass = ClassUtil.nonNullState((EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier_0, TYP_ecore_c_c_EClass_1));
-						CAUGHT_targetEClass = targetEClass;
-					}
-					catch (Exception e) {
-						CAUGHT_targetEClass = ValueUtil.createInvalidValue(e);
-					}
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode source_3 = this.getSource();
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode target_4 = this.getTarget();
-					/*@Caught*/ @Nullable Object CAUGHT_and_3;
-					try {
-						/*@Caught*/ @Nullable Object CAUGHT_and_2;
+						/*@Caught*/ @NonNull Object CAUGHT_sourceEClass;
 						try {
-							/*@Caught*/ @Nullable Object CAUGHT_and_1;
-							try {
-								/*@Caught*/ @NonNull Object CAUGHT_eq_0;
-								try {
-									if (CAUGHT_sourceEClass instanceof InvalidValueException) {
-										throw (InvalidValueException)CAUGHT_sourceEClass;
-									}
-									if (CAUGHT_targetEClass instanceof InvalidValueException) {
-										throw (InvalidValueException)CAUGHT_targetEClass;
-									}
-									final /*@Thrown*/ boolean eq_0 = CAUGHT_sourceEClass.equals(CAUGHT_targetEClass);
-									CAUGHT_eq_0 = eq_0;
-								}
-								catch (Exception e) {
-									CAUGHT_eq_0 = ValueUtil.createInvalidValue(e);
-								}
-								final /*@NonInvalid*/ boolean isMany = source_3.isIsMany();
-								final /*@NonInvalid*/ boolean isMany_0 = target_4.isIsMany();
-								final /*@NonInvalid*/ boolean eq_1 = isMany == isMany_0;
-								final /*@Thrown*/ java.lang.@Nullable Boolean and_1 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_eq_0, eq_1);
-								CAUGHT_and_1 = and_1;
-							}
-							catch (Exception e) {
-								CAUGHT_and_1 = ValueUtil.createInvalidValue(e);
-							}
-							final /*@NonInvalid*/ boolean isNullFree = source_3.isIsNullFree();
-							final /*@NonInvalid*/ boolean isNullFree_0 = target_4.isIsNullFree();
-							final /*@NonInvalid*/ boolean eq_2 = isNullFree == isNullFree_0;
-							final /*@Thrown*/ java.lang.@Nullable Boolean and_2 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and_1, eq_2);
-							CAUGHT_and_2 = and_2;
+							final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_0 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
+							@SuppressWarnings("null")
+							final /*@NonInvalid*/ @NonNull RelPatternNode source = this.getSource();
+							final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = source.getReferredEClassifier();
+							@SuppressWarnings("null")
+							final /*@Thrown*/ @NonNull EClass sourceEClass = (@NonNull EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClass_0);
+							CAUGHT_sourceEClass = sourceEClass;
 						}
 						catch (Exception e) {
-							CAUGHT_and_2 = ValueUtil.createInvalidValue(e);
+							CAUGHT_sourceEClass = ValueUtil.createInvalidValue(e);
 						}
-						final /*@NonInvalid*/ boolean isOrdered = source_3.isIsOrdered();
-						final /*@NonInvalid*/ boolean isOrdered_0 = target_4.isIsOrdered();
-						final /*@NonInvalid*/ boolean eq_3 = isOrdered == isOrdered_0;
-						final /*@Thrown*/ java.lang.@Nullable Boolean and_3 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and_2, eq_3);
-						CAUGHT_and_3 = and_3;
+						/*@Caught*/ @NonNull Object CAUGHT_targetEClass;
+						try {
+							final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_1 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
+							@SuppressWarnings("null")
+							final /*@NonInvalid*/ @NonNull RelPatternNode target_0 = this.getTarget();
+							final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier_0 = target_0.getReferredEClassifier();
+							@SuppressWarnings("null")
+							final /*@Thrown*/ @NonNull EClass targetEClass = (@NonNull EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier_0, TYP_ecore_c_c_EClass_1);
+							CAUGHT_targetEClass = targetEClass;
+						}
+						catch (Exception e) {
+							CAUGHT_targetEClass = ValueUtil.createInvalidValue(e);
+						}
+						@SuppressWarnings("null")
+						final /*@NonInvalid*/ @NonNull RelPatternNode source_3 = this.getSource();
+						@SuppressWarnings("null")
+						final /*@NonInvalid*/ @NonNull RelPatternNode target_4 = this.getTarget();
+						/*@Caught*/ @Nullable Object CAUGHT_and_3;
+						try {
+							/*@Caught*/ @Nullable Object CAUGHT_and_2;
+							try {
+								/*@Caught*/ @Nullable Object CAUGHT_and_1;
+								try {
+									/*@Caught*/ @NonNull Object CAUGHT_eq_0;
+									try {
+										if (CAUGHT_sourceEClass instanceof InvalidValueException) {
+											throw (InvalidValueException)CAUGHT_sourceEClass;
+										}
+										if (CAUGHT_targetEClass instanceof InvalidValueException) {
+											throw (InvalidValueException)CAUGHT_targetEClass;
+										}
+										final /*@Thrown*/ boolean eq_0 = CAUGHT_sourceEClass.equals(CAUGHT_targetEClass);
+										CAUGHT_eq_0 = eq_0;
+									}
+									catch (Exception e) {
+										CAUGHT_eq_0 = ValueUtil.createInvalidValue(e);
+									}
+									final /*@NonInvalid*/ boolean isMany = source_3.isIsMany();
+									final /*@NonInvalid*/ boolean isMany_0 = target_4.isIsMany();
+									final /*@NonInvalid*/ boolean eq_1 = isMany == isMany_0;
+									final /*@Thrown*/ @Nullable Boolean and_1 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_eq_0, eq_1);
+									CAUGHT_and_1 = and_1;
+								}
+								catch (Exception e) {
+									CAUGHT_and_1 = ValueUtil.createInvalidValue(e);
+								}
+								final /*@NonInvalid*/ boolean isNullFree = source_3.isIsNullFree();
+								final /*@NonInvalid*/ boolean isNullFree_0 = target_4.isIsNullFree();
+								final /*@NonInvalid*/ boolean eq_2 = isNullFree == isNullFree_0;
+								final /*@Thrown*/ @Nullable Boolean and_2 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and_1, eq_2);
+								CAUGHT_and_2 = and_2;
+							}
+							catch (Exception e) {
+								CAUGHT_and_2 = ValueUtil.createInvalidValue(e);
+							}
+							final /*@NonInvalid*/ boolean isOrdered = source_3.isIsOrdered();
+							final /*@NonInvalid*/ boolean isOrdered_0 = target_4.isIsOrdered();
+							final /*@NonInvalid*/ boolean eq_3 = isOrdered == isOrdered_0;
+							final /*@Thrown*/ @Nullable Boolean and_3 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and_2, eq_3);
+							CAUGHT_and_3 = and_3;
+						}
+						catch (Exception e) {
+							CAUGHT_and_3 = ValueUtil.createInvalidValue(e);
+						}
+						final /*@NonInvalid*/ boolean isUnique = source_3.isIsUnique();
+						final /*@NonInvalid*/ boolean isUnique_0 = target_4.isIsUnique();
+						final /*@NonInvalid*/ boolean eq_4 = isUnique == isUnique_0;
+						final /*@Thrown*/ @Nullable Boolean and_4 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and_3, eq_4);
+						CAUGHT_and_4 = and_4;
 					}
 					catch (Exception e) {
-						CAUGHT_and_3 = ValueUtil.createInvalidValue(e);
+						CAUGHT_and_4 = ValueUtil.createInvalidValue(e);
 					}
-					final /*@NonInvalid*/ boolean isUnique = source_3.isIsUnique();
-					final /*@NonInvalid*/ boolean isUnique_0 = target_4.isIsUnique();
-					final /*@NonInvalid*/ boolean eq_4 = isUnique == isUnique_0;
-					final /*@Thrown*/ java.lang.@Nullable Boolean and_4 = BooleanAndOperation.INSTANCE.evaluate(CAUGHT_and_3, eq_4);
-					CAUGHT_and_4 = and_4;
+					final /*@Thrown*/ @Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(and_0, CAUGHT_and_4);
+					CAUGHT_result = result;
 				}
 				catch (Exception e) {
-					CAUGHT_and_4 = ValueUtil.createInvalidValue(e);
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
 				}
-				final /*@Thrown*/ java.lang.@Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(and_0, CAUGHT_and_4);
-				CAUGHT_result = result;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleRestPropertyTarget, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleRestPropertyTarget, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternEdge::CompatibleRestPropertyTarget", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -1025,186 +1085,195 @@
 	 */
 	@Override
 	public boolean validateCompatibleMemberPropertyTarget(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv CompatibleMemberPropertyTarget:
-		 *   let
-		 *     severity : Integer[1] = 'RelPatternEdge::CompatibleMemberPropertyTarget'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[?] = referredEStructuralFeature = null and sourceIndex > 0 and
-		 *         not target.isExpression() implies
-		 *         let
-		 *           sourceEClass : ecore::EClass[1] = source.referredEClassifier.oclAsType(ecore::EClass)
-		 *         in
-		 *           let
-		 *             targetEClass : ecore::EClass[1] = target.referredEClassifier.oclAsType(ecore::EClass)
-		 *           in
-		 *             sourceEClass->closure(eSuperTypes)
-		 *             ->includes(targetEClass) or
-		 *             targetEClass->closure(eSuperTypes)
-		 *             ->includes(sourceEClass)
-		 *       in
-		 *         'RelPatternEdge::CompatibleMemberPropertyTarget'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull StandardLibrary standardLibrary = idResolver.getStandardLibrary();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleMemberPropertyTarget);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_2;
-		if (le) {
-			symbol_2 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @Nullable Object CAUGHT_result;
-			try {
-				final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
-				final /*@NonInvalid*/ boolean eq = referredEStructuralFeature == null;
-				/*@NonInvalid*/ boolean and;
-				if (eq) {
-					final /*@NonInvalid*/ int sourceIndex = this.getSourceIndex();
-					final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue BOXED_sourceIndex = ValueUtil.integerValueOf(sourceIndex);
-					final /*@NonInvalid*/ boolean gt = OclComparableGreaterThanOperation.INSTANCE.evaluate(executor, BOXED_sourceIndex, UMLXTables.INT_0).booleanValue();
-					and = gt;
-				}
-				else {
-					and = ValueUtil.FALSE_VALUE;
-				}
-				/*@NonInvalid*/ java.lang.@Nullable Boolean and_0;
-				if (and) {
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode target = this.getTarget();
-					final /*@NonInvalid*/ boolean isExpression = target.isExpression();
-					final /*@NonInvalid*/ java.lang.@Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-					and_0 = not;
-				}
-				else {
-					and_0 = ValueUtil.FALSE_VALUE;
-				}
-				/*@Caught*/ @Nullable Object CAUGHT_or;
+		try {
+			/**
+			 *
+			 * inv CompatibleMemberPropertyTarget:
+			 *   let
+			 *     severity : Integer[1] = 'RelPatternEdge::CompatibleMemberPropertyTarget'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[?] = referredEStructuralFeature = null and sourceIndex > 0 and
+			 *         not target.isExpression() implies
+			 *         let
+			 *           sourceEClass : ecore::EClass[1] = source.referredEClassifier.oclAsType(ecore::EClass)
+			 *         in
+			 *           let
+			 *             targetEClass : ecore::EClass[1] = target.referredEClassifier.oclAsType(ecore::EClass)
+			 *           in
+			 *             sourceEClass->closure(eSuperTypes)
+			 *             ->includes(targetEClass) or
+			 *             targetEClass->closure(eSuperTypes)
+			 *             ->includes(sourceEClass)
+			 *       in
+			 *         'RelPatternEdge::CompatibleMemberPropertyTarget'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull StandardLibrary standardLibrary = idResolver.getStandardLibrary();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternEdge_c_c_CompatibleMemberPropertyTarget);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_2;
+			if (le) {
+				symbol_2 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @Nullable Object CAUGHT_result;
 				try {
-					/*@Caught*/ @NonNull Object CAUGHT_sourceEClass;
-					try {
-						final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_0 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
+					final /*@NonInvalid*/ @Nullable EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
+					final /*@NonInvalid*/ boolean eq = referredEStructuralFeature == null;
+					/*@NonInvalid*/ boolean and;
+					if (eq) {
+						final /*@NonInvalid*/ int sourceIndex = this.getSourceIndex();
+						final /*@NonInvalid*/ @NonNull IntegerValue BOXED_sourceIndex = ValueUtil.integerValueOf(sourceIndex);
+						final /*@NonInvalid*/ boolean gt = OclComparableGreaterThanOperation.INSTANCE.evaluate(executor, BOXED_sourceIndex, UMLXTables.INT_0).booleanValue();
+						and = gt;
+					}
+					else {
+						and = ValueUtil.FALSE_VALUE;
+					}
+					/*@NonInvalid*/ @Nullable Boolean and_0;
+					if (and) {
 						@SuppressWarnings("null")
-						final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode source = this.getSource();
-						final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = source.getReferredEClassifier();
-						final /*@Thrown*/ org.eclipse.emf.ecore.@NonNull EClass sourceEClass = ClassUtil.nonNullState((EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClass_0));
-						CAUGHT_sourceEClass = sourceEClass;
+						final /*@NonInvalid*/ @NonNull RelPatternNode target = this.getTarget();
+						final /*@NonInvalid*/ boolean isExpression = target.isExpression();
+						final /*@NonInvalid*/ @Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+						and_0 = not;
 					}
-					catch (Exception e) {
-						CAUGHT_sourceEClass = ValueUtil.createInvalidValue(e);
+					else {
+						and_0 = ValueUtil.FALSE_VALUE;
 					}
-					/*@Caught*/ @NonNull Object CAUGHT_targetEClass;
+					/*@Caught*/ @Nullable Object CAUGHT_or;
 					try {
-						final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_1 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
-						@SuppressWarnings("null")
-						final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelPatternNode target_0 = this.getTarget();
-						final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier_0 = target_0.getReferredEClassifier();
-						final /*@Thrown*/ org.eclipse.emf.ecore.@NonNull EClass targetEClass = ClassUtil.nonNullState((EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier_0, TYP_ecore_c_c_EClass_1));
-						CAUGHT_targetEClass = targetEClass;
-					}
-					catch (Exception e) {
-						CAUGHT_targetEClass = ValueUtil.createInvalidValue(e);
-					}
-					/*@Caught*/ @NonNull Object CAUGHT_includes;
-					try {
-						if (CAUGHT_sourceEClass instanceof InvalidValueException) {
-							throw (InvalidValueException)CAUGHT_sourceEClass;
+						/*@Caught*/ @NonNull Object CAUGHT_sourceEClass;
+						try {
+							final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_0 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
+							@SuppressWarnings("null")
+							final /*@NonInvalid*/ @NonNull RelPatternNode source = this.getSource();
+							final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = source.getReferredEClassifier();
+							@SuppressWarnings("null")
+							final /*@Thrown*/ @NonNull EClass sourceEClass = (@NonNull EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier, TYP_ecore_c_c_EClass_0);
+							CAUGHT_sourceEClass = sourceEClass;
 						}
-						final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue oclAsSet = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, CAUGHT_sourceEClass);
-						final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_1 = executor.getStaticTypeOf(oclAsSet);
-						final LibraryIteration.@org.eclipse.jdt.annotation.NonNull LibraryIterationExtension IMPL_closure_1 = (LibraryIteration.LibraryIterationExtension)TYPE_closure_1.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
-						final @NonNull Object ACC_closure_1 = IMPL_closure_1.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
-						/**
-						 * Implementation of the iterator body.
-						 */
-						final @NonNull AbstractBinaryOperation BODY_closure_1 = new AbstractBinaryOperation() {
-							/**
-							 * eSuperTypes
-							 */
-							@Override
-							public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet, final /*@NonInvalid*/ java.lang.@Nullable Object _1) {
-								final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClass symbol_0 = (EClass)_1;
-								if (symbol_0 == null) {
-									throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
-								}
-								@SuppressWarnings("null")
-								final /*@Thrown*/ java.util.@NonNull List<EClass> eSuperTypes = symbol_0.getESuperTypes();
-								final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_eSuperTypes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes);
-								return BOXED_eSuperTypes;
+						catch (Exception e) {
+							CAUGHT_sourceEClass = ValueUtil.createInvalidValue(e);
+						}
+						/*@Caught*/ @NonNull Object CAUGHT_targetEClass;
+						try {
+							final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_1 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
+							@SuppressWarnings("null")
+							final /*@NonInvalid*/ @NonNull RelPatternNode target_0 = this.getTarget();
+							final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier_0 = target_0.getReferredEClassifier();
+							@SuppressWarnings("null")
+							final /*@Thrown*/ @NonNull EClass targetEClass = (@NonNull EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClassifier_0, TYP_ecore_c_c_EClass_1);
+							CAUGHT_targetEClass = targetEClass;
+						}
+						catch (Exception e) {
+							CAUGHT_targetEClass = ValueUtil.createInvalidValue(e);
+						}
+						/*@Caught*/ @NonNull Object CAUGHT_includes;
+						try {
+							if (CAUGHT_sourceEClass instanceof InvalidValueException) {
+								throw (InvalidValueException)CAUGHT_sourceEClass;
 							}
-						};
-						final @NonNull  ExecutorSingleIterationManager MGR_closure_1 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_1, oclAsSet, ACC_closure_1);
-						final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue closure = ClassUtil.nonNullState((SetValue)IMPL_closure_1.evaluateIteration(MGR_closure_1));
-						if (CAUGHT_targetEClass instanceof InvalidValueException) {
-							throw (InvalidValueException)CAUGHT_targetEClass;
-						}
-						final /*@Thrown*/ boolean includes = CollectionIncludesOperation.INSTANCE.evaluate(closure, CAUGHT_targetEClass).booleanValue();
-						CAUGHT_includes = includes;
-					}
-					catch (Exception e) {
-						CAUGHT_includes = ValueUtil.createInvalidValue(e);
-					}
-					/*@Caught*/ @NonNull Object CAUGHT_includes_0;
-					try {
-						if (CAUGHT_targetEClass instanceof InvalidValueException) {
-							throw (InvalidValueException)CAUGHT_targetEClass;
-						}
-						final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue oclAsSet_0 = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, CAUGHT_targetEClass);
-						final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_0_0 = executor.getStaticTypeOf(oclAsSet_0);
-						final LibraryIteration.@org.eclipse.jdt.annotation.NonNull LibraryIterationExtension IMPL_closure_0_0 = (LibraryIteration.LibraryIterationExtension)TYPE_closure_0_0.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
-						final @NonNull Object ACC_closure_0_0 = IMPL_closure_0_0.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
-						/**
-						 * Implementation of the iterator body.
-						 */
-						final @NonNull AbstractBinaryOperation BODY_closure_0_0 = new AbstractBinaryOperation() {
+							final /*@Thrown*/ @NonNull SetValue oclAsSet = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, CAUGHT_sourceEClass);
+							final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_1 = executor.getStaticTypeOfValue(null, oclAsSet);
+							final @NonNull LibraryIterationExtension IMPL_closure_1 = (LibraryIterationExtension)TYPE_closure_1.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
+							final @NonNull Object ACC_closure_1 = IMPL_closure_1.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
 							/**
-							 * eSuperTypes
+							 * Implementation of the iterator body.
 							 */
-							@Override
-							public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet_0, final /*@NonInvalid*/ java.lang.@Nullable Object _1_0) {
-								final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClass symbol_1 = (EClass)_1_0;
-								if (symbol_1 == null) {
-									throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
+							final @NonNull AbstractBinaryOperation BODY_closure_1 = new AbstractBinaryOperation() {
+								/**
+								 * eSuperTypes
+								 */
+								@Override
+								public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet, final /*@NonInvalid*/ @Nullable Object _1) {
+									final /*@NonInvalid*/ @Nullable EClass symbol_0 = (EClass)_1;
+									if (symbol_0 == null) {
+										throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
+									}
+									@SuppressWarnings("null")
+									final /*@Thrown*/ @NonNull List<EClass> eSuperTypes = symbol_0.getESuperTypes();
+									final /*@Thrown*/ @NonNull OrderedSetValue BOXED_eSuperTypes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes);
+									return BOXED_eSuperTypes;
 								}
-								@SuppressWarnings("null")
-								final /*@Thrown*/ java.util.@NonNull List<EClass> eSuperTypes_0 = symbol_1.getESuperTypes();
-								final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_eSuperTypes_0 = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes_0);
-								return BOXED_eSuperTypes_0;
+							};
+							final @NonNull ExecutorSingleIterationManager MGR_closure_1 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_1, oclAsSet, ACC_closure_1);
+							@SuppressWarnings("null")
+							final /*@Thrown*/ @NonNull SetValue closure = (@NonNull SetValue)IMPL_closure_1.evaluateIteration(MGR_closure_1);
+							if (CAUGHT_targetEClass instanceof InvalidValueException) {
+								throw (InvalidValueException)CAUGHT_targetEClass;
 							}
-						};
-						final @NonNull  ExecutorSingleIterationManager MGR_closure_0_0 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_0_0, oclAsSet_0, ACC_closure_0_0);
-						final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue closure_0 = ClassUtil.nonNullState((SetValue)IMPL_closure_0_0.evaluateIteration(MGR_closure_0_0));
-						if (CAUGHT_sourceEClass instanceof InvalidValueException) {
-							throw (InvalidValueException)CAUGHT_sourceEClass;
+							final /*@Thrown*/ boolean includes = CollectionIncludesOperation.INSTANCE.evaluate(closure, CAUGHT_targetEClass).booleanValue();
+							CAUGHT_includes = includes;
 						}
-						final /*@Thrown*/ boolean includes_0 = CollectionIncludesOperation.INSTANCE.evaluate(closure_0, CAUGHT_sourceEClass).booleanValue();
-						CAUGHT_includes_0 = includes_0;
+						catch (Exception e) {
+							CAUGHT_includes = ValueUtil.createInvalidValue(e);
+						}
+						/*@Caught*/ @NonNull Object CAUGHT_includes_0;
+						try {
+							if (CAUGHT_targetEClass instanceof InvalidValueException) {
+								throw (InvalidValueException)CAUGHT_targetEClass;
+							}
+							final /*@Thrown*/ @NonNull SetValue oclAsSet_0 = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, CAUGHT_targetEClass);
+							final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_0_0 = executor.getStaticTypeOfValue(null, oclAsSet_0);
+							final @NonNull LibraryIterationExtension IMPL_closure_0_0 = (LibraryIterationExtension)TYPE_closure_0_0.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
+							final @NonNull Object ACC_closure_0_0 = IMPL_closure_0_0.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
+							/**
+							 * Implementation of the iterator body.
+							 */
+							final @NonNull AbstractBinaryOperation BODY_closure_0_0 = new AbstractBinaryOperation() {
+								/**
+								 * eSuperTypes
+								 */
+								@Override
+								public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet_0, final /*@NonInvalid*/ @Nullable Object _1_0) {
+									final /*@NonInvalid*/ @Nullable EClass symbol_1 = (EClass)_1_0;
+									if (symbol_1 == null) {
+										throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
+									}
+									@SuppressWarnings("null")
+									final /*@Thrown*/ @NonNull List<EClass> eSuperTypes_0 = symbol_1.getESuperTypes();
+									final /*@Thrown*/ @NonNull OrderedSetValue BOXED_eSuperTypes_0 = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes_0);
+									return BOXED_eSuperTypes_0;
+								}
+							};
+							final @NonNull ExecutorSingleIterationManager MGR_closure_0_0 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_0_0, oclAsSet_0, ACC_closure_0_0);
+							@SuppressWarnings("null")
+							final /*@Thrown*/ @NonNull SetValue closure_0 = (@NonNull SetValue)IMPL_closure_0_0.evaluateIteration(MGR_closure_0_0);
+							if (CAUGHT_sourceEClass instanceof InvalidValueException) {
+								throw (InvalidValueException)CAUGHT_sourceEClass;
+							}
+							final /*@Thrown*/ boolean includes_0 = CollectionIncludesOperation.INSTANCE.evaluate(closure_0, CAUGHT_sourceEClass).booleanValue();
+							CAUGHT_includes_0 = includes_0;
+						}
+						catch (Exception e) {
+							CAUGHT_includes_0 = ValueUtil.createInvalidValue(e);
+						}
+						final /*@Thrown*/ @Nullable Boolean or = BooleanOrOperation.INSTANCE.evaluate(CAUGHT_includes, CAUGHT_includes_0);
+						CAUGHT_or = or;
 					}
 					catch (Exception e) {
-						CAUGHT_includes_0 = ValueUtil.createInvalidValue(e);
+						CAUGHT_or = ValueUtil.createInvalidValue(e);
 					}
-					final /*@Thrown*/ java.lang.@Nullable Boolean or = BooleanOrOperation.INSTANCE.evaluate(CAUGHT_includes, CAUGHT_includes_0);
-					CAUGHT_or = or;
+					final /*@Thrown*/ @Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(and_0, CAUGHT_or);
+					CAUGHT_result = result;
 				}
 				catch (Exception e) {
-					CAUGHT_or = ValueUtil.createInvalidValue(e);
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
 				}
-				final /*@Thrown*/ java.lang.@Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(and_0, CAUGHT_or);
-				CAUGHT_result = result;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleMemberPropertyTarget, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_2 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternEdge_c_c_CompatibleMemberPropertyTarget, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_2 = logDiagnostic;
+			return Boolean.TRUE == symbol_2;
 		}
-		return Boolean.TRUE == symbol_2;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternEdge::CompatibleMemberPropertyTarget", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -1214,7 +1283,13 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (sourceIndex: ");
+		result.append(sourceIndex);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -1225,17 +1300,17 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				return getOwningRelDomainNode();
-			case UMLXPackage.REL_PATTERN_EDGE__REFERRED_ESTRUCTURAL_FEATURE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				if (resolve) return getReferredEStructuralFeature();
 				return basicGetReferredEStructuralFeature();
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				if (resolve) return getSource();
 				return basicGetSource();
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE_INDEX:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 3:
 				return getSourceIndex();
-			case UMLXPackage.REL_PATTERN_EDGE__TARGET:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4:
 				if (resolve) return getTarget();
 				return basicGetTarget();
 		}
@@ -1250,19 +1325,19 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				setOwningRelDomainNode((RelDomainNode)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_EDGE__REFERRED_ESTRUCTURAL_FEATURE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				setReferredEStructuralFeature((EStructuralFeature)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				setSource((RelPatternNode)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE_INDEX:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 3:
 				setSourceIndex((Integer)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_EDGE__TARGET:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4:
 				setTarget((RelPatternNode)newValue);
 				return;
 		}
@@ -1277,19 +1352,19 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				setOwningRelDomainNode((RelDomainNode)null);
 				return;
-			case UMLXPackage.REL_PATTERN_EDGE__REFERRED_ESTRUCTURAL_FEATURE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				setReferredEStructuralFeature((EStructuralFeature)null);
 				return;
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				setSource((RelPatternNode)null);
 				return;
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE_INDEX:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 3:
 				setSourceIndex(SOURCE_INDEX_EDEFAULT);
 				return;
-			case UMLXPackage.REL_PATTERN_EDGE__TARGET:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4:
 				setTarget((RelPatternNode)null);
 				return;
 		}
@@ -1304,15 +1379,15 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				return getOwningRelDomainNode() != null;
-			case UMLXPackage.REL_PATTERN_EDGE__REFERRED_ESTRUCTURAL_FEATURE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1:
 				return referredEStructuralFeature != null;
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				return source != null;
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE_INDEX:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 3:
 				return sourceIndex != SOURCE_INDEX_EDEFAULT;
-			case UMLXPackage.REL_PATTERN_EDGE__TARGET:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4:
 				return target != null;
 		}
 		return super.eIsSet(featureID);
@@ -1335,17 +1410,17 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningRelDomainNode((RelDomainNode)otherEnd, msgs);
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				if (source != null)
-					msgs = ((InternalEObject)source).eInverseRemove(this, UMLXPackage.REL_PATTERN_NODE__OUTGOING, RelPatternNode.class, msgs);
+					msgs = ((InternalEObject)source).eInverseRemove(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 12, RelPatternNode.class, msgs);
 				return basicSetSource((RelPatternNode)otherEnd, msgs);
-			case UMLXPackage.REL_PATTERN_EDGE__TARGET:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4:
 				if (target != null)
-					msgs = ((InternalEObject)target).eInverseRemove(this, UMLXPackage.REL_PATTERN_NODE__INCOMING, RelPatternNode.class, msgs);
+					msgs = ((InternalEObject)target).eInverseRemove(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 7, RelPatternNode.class, msgs);
 				return basicSetTarget((RelPatternNode)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
@@ -1359,11 +1434,11 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
 				return basicSetOwningRelDomainNode(null, msgs);
-			case UMLXPackage.REL_PATTERN_EDGE__SOURCE:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2:
 				return basicSetSource(null, msgs);
-			case UMLXPackage.REL_PATTERN_EDGE__TARGET:
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4:
 				return basicSetTarget(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -1377,8 +1452,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES, RelDomainNode.class, msgs);
+			case RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0:
+				return eInternalContainer().eInverseRemove(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 1, RelDomainNode.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelPatternNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelPatternNodeImpl.java
index 209ecff..97398f6 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelPatternNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/RelPatternNodeImpl.java
@@ -12,6 +12,7 @@
 
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
@@ -28,8 +29,9 @@
 import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.evaluation.Executor;
+import org.eclipse.ocl.pivot.ids.IdResolver;
 import org.eclipse.ocl.pivot.ids.TypeId;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.collection.CollectionIncludesOperation;
 import org.eclipse.ocl.pivot.library.collection.CollectionNotEmptyOperation;
 import org.eclipse.ocl.pivot.library.logical.BooleanImpliesOperation;
@@ -37,13 +39,18 @@
 import org.eclipse.ocl.pivot.library.oclany.OclComparableLessThanEqualOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
+import org.eclipse.ocl.pivot.values.IntegerValue;
 import org.eclipse.ocl.pivot.values.InvalidValueException;
+import org.eclipse.ocl.pivot.values.OrderedSetValue;
 import org.eclipse.ocl.pivot.values.SequenceValue;
+import org.eclipse.ocl.pivot.values.SequenceValue.Accumulator;
 import org.eclipse.qvtd.umlx.RelDomainNode;
 import org.eclipse.qvtd.umlx.RelInvocationEdge;
 import org.eclipse.qvtd.umlx.RelPatternNode;
 import org.eclipse.qvtd.umlx.TxPackageNode;
+import org.eclipse.qvtd.umlx.TxTypedModelNode;
 import org.eclipse.qvtd.umlx.UMLXNamedElement;
 import org.eclipse.qvtd.umlx.RelPatternEdge;
 import org.eclipse.qvtd.umlx.UMLXPackage;
@@ -79,6 +86,14 @@
  */
 public class RelPatternNodeImpl extends RelNodeImpl implements RelPatternNode {
 	/**
+	 * The number of structural features of the '<em>Rel Pattern Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int REL_PATTERN_NODE_FEATURE_COUNT = RelNodeImpl.REL_NODE_FEATURE_COUNT + 14;
+	/**
 	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -306,7 +321,7 @@
 		String oldName = name;
 		name = newName;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__NAME, oldName, name));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 0, oldName, name));
 	}
 
 	/**
@@ -329,7 +344,7 @@
 		boolean oldIsMany = isMany;
 		isMany = newIsMany;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__IS_MANY, oldIsMany, isMany));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 1, oldIsMany, isMany));
 	}
 
 	/**
@@ -352,7 +367,7 @@
 		boolean oldIsNullFree = isNullFree;
 		isNullFree = newIsNullFree;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__IS_NULL_FREE, oldIsNullFree, isNullFree));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 2, oldIsNullFree, isNullFree));
 	}
 
 	/**
@@ -375,7 +390,7 @@
 		boolean oldIsOrdered = isOrdered;
 		isOrdered = newIsOrdered;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__IS_ORDERED, oldIsOrdered, isOrdered));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 3, oldIsOrdered, isOrdered));
 	}
 
 	/**
@@ -398,7 +413,7 @@
 		boolean oldIsRequired = isRequired;
 		isRequired = newIsRequired;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__IS_REQUIRED, oldIsRequired, isRequired));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 4, oldIsRequired, isRequired));
 	}
 
 	/**
@@ -421,7 +436,7 @@
 		boolean oldIsUnique = isUnique;
 		isUnique = newIsUnique;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__IS_UNIQUE, oldIsUnique, isUnique));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 5, oldIsUnique, isUnique));
 	}
 
 	/**
@@ -436,7 +451,7 @@
 			referredEClassifier = (EClassifier)eResolveProxy(oldReferredEClassifier);
 			if (referredEClassifier != oldReferredEClassifier) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.REL_PATTERN_NODE__REFERRED_ECLASSIFIER, oldReferredEClassifier, referredEClassifier));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, RelNodeImpl.REL_NODE_FEATURE_COUNT + 6, oldReferredEClassifier, referredEClassifier));
 			}
 		}
 		return referredEClassifier;
@@ -461,7 +476,7 @@
 		EClassifier oldReferredEClassifier = referredEClassifier;
 		referredEClassifier = newReferredEClassifier;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__REFERRED_ECLASSIFIER, oldReferredEClassifier, referredEClassifier));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 6, oldReferredEClassifier, referredEClassifier));
 	}
 
 	/**
@@ -472,7 +487,7 @@
 	@Override
 	public EList<RelPatternEdge> getIncoming() {
 		if (incoming == null) {
-			incoming = new EObjectWithInverseResolvingEList<RelPatternEdge>(RelPatternEdge.class, this, UMLXPackage.REL_PATTERN_NODE__INCOMING, UMLXPackage.REL_PATTERN_EDGE__TARGET);
+			incoming = new EObjectWithInverseResolvingEList<RelPatternEdge>(RelPatternEdge.class, this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 7, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4);
 		}
 		return incoming;
 	}
@@ -485,7 +500,7 @@
 	@Override
 	public EList<String> getInitExpressionLines() {
 		if (initExpressionLines == null) {
-			initExpressionLines = new EDataTypeUniqueEList<String>(String.class, this, UMLXPackage.REL_PATTERN_NODE__INIT_EXPRESSION_LINES);
+			initExpressionLines = new EDataTypeUniqueEList<String>(String.class, this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 8);
 		}
 		return initExpressionLines;
 	}
@@ -510,7 +525,7 @@
 		boolean oldIsRoot = isRoot;
 		isRoot = newIsRoot;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__IS_ROOT, oldIsRoot, isRoot));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 11, oldIsRoot, isRoot));
 	}
 
 	/**
@@ -521,7 +536,7 @@
 	@Override
 	public EList<RelPatternEdge> getOutgoing() {
 		if (outgoing == null) {
-			outgoing = new EObjectWithInverseResolvingEList<RelPatternEdge>(RelPatternEdge.class, this, UMLXPackage.REL_PATTERN_NODE__OUTGOING, UMLXPackage.REL_PATTERN_EDGE__SOURCE);
+			outgoing = new EObjectWithInverseResolvingEList<RelPatternEdge>(RelPatternEdge.class, this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 12, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2);
 		}
 		return outgoing;
 	}
@@ -533,7 +548,7 @@
 	 */
 	@Override
 	public RelDomainNode getOwningRelDomainNode() {
-		if (eContainerFeatureID() != UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE) return null;
+		if (eContainerFeatureID() != (RelNodeImpl.REL_NODE_FEATURE_COUNT + 13)) return null;
 		return (RelDomainNode)eInternalContainer();
 	}
 
@@ -543,7 +558,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningRelDomainNode(RelDomainNode newOwningRelDomainNode, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningRelDomainNode, UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningRelDomainNode, RelNodeImpl.REL_NODE_FEATURE_COUNT + 13, msgs);
 		return msgs;
 	}
 
@@ -554,19 +569,19 @@
 	 */
 	@Override
 	public void setOwningRelDomainNode(RelDomainNode newOwningRelDomainNode) {
-		if (newOwningRelDomainNode != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE && newOwningRelDomainNode != null)) {
+		if (newOwningRelDomainNode != eInternalContainer() || (eContainerFeatureID() != (RelNodeImpl.REL_NODE_FEATURE_COUNT + 13) && newOwningRelDomainNode != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningRelDomainNode))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningRelDomainNode != null)
-				msgs = ((InternalEObject)newOwningRelDomainNode).eInverseAdd(this, UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES, RelDomainNode.class, msgs);
+				msgs = ((InternalEObject)newOwningRelDomainNode).eInverseAdd(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 2, RelDomainNode.class, msgs);
 			msgs = basicSetOwningRelDomainNode(newOwningRelDomainNode, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE, newOwningRelDomainNode, newOwningRelDomainNode));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 13, newOwningRelDomainNode, newOwningRelDomainNode));
 	}
 
 	/**
@@ -579,15 +594,15 @@
 		/**
 		 * name = null and initExpressionLines->notEmpty()
 		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ java.lang.@Nullable String name = this.getName();
+		final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this);
+		final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+		final /*@NonInvalid*/ @Nullable String name = this.getName();
 		final /*@NonInvalid*/ boolean eq = name == null;
 		/*@NonInvalid*/ boolean and;
 		if (eq) {
 			@SuppressWarnings("null")
-			final /*@NonInvalid*/ java.util.@NonNull List<String> initExpressionLines = this.getInitExpressionLines();
-			final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_initExpressionLines = idResolver.createOrderedSetOfAll(UMLXTables.ORD_PRIMid_String, initExpressionLines);
+			final /*@NonInvalid*/ @NonNull List<String> initExpressionLines = this.getInitExpressionLines();
+			final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_initExpressionLines = idResolver.createOrderedSetOfAll(UMLXTables.ORD_PRIMid_String, initExpressionLines);
 			final /*@NonInvalid*/ boolean notEmpty = CollectionNotEmptyOperation.INSTANCE.evaluate(BOXED_initExpressionLines).booleanValue();
 			and = notEmpty;
 		}
@@ -604,45 +619,50 @@
 	 */
 	@Override
 	public boolean validateAnonIsUnnamed(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv AnonIsUnnamed:
-		 *   let severity : Integer[1] = 'RelPatternNode::AnonIsUnnamed'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[?] = not isExpression() implies isAnon = name = ''
-		 *       in
-		 *         'RelPatternNode::AnonIsUnnamed'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternNode_c_c_AnonIsUnnamed);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @Nullable Object CAUGHT_result;
-			try {
-				final /*@NonInvalid*/ boolean isExpression = this.isExpression();
-				final /*@NonInvalid*/ java.lang.@Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-				final /*@NonInvalid*/ boolean isAnon = this.isIsAnon();
-				final /*@NonInvalid*/ java.lang.@Nullable String name = this.getName();
-				final /*@NonInvalid*/ boolean eq = UMLXTables.STR_.equals(name);
-				final /*@NonInvalid*/ boolean eq_0 = isAnon == eq;
-				final /*@Thrown*/ java.lang.@Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(not, eq_0);
-				CAUGHT_result = result;
+		try {
+			/**
+			 *
+			 * inv AnonIsUnnamed:
+			 *   let severity : Integer[1] = 'RelPatternNode::AnonIsUnnamed'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[?] = not isExpression() implies isAnon = name = ''
+			 *       in
+			 *         'RelPatternNode::AnonIsUnnamed'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternNode_c_c_AnonIsUnnamed);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
+			else {
+				/*@Caught*/ @Nullable Object CAUGHT_result;
+				try {
+					final /*@NonInvalid*/ boolean isExpression = this.isExpression();
+					final /*@NonInvalid*/ @Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+					final /*@NonInvalid*/ boolean isAnon = this.isIsAnon();
+					final /*@NonInvalid*/ @Nullable String name = this.getName();
+					final /*@NonInvalid*/ boolean eq = UMLXTables.STR_.equals(name);
+					final /*@NonInvalid*/ boolean eq_0 = isAnon == eq;
+					final /*@Thrown*/ @Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(not, eq_0);
+					CAUGHT_result = result;
+				}
+				catch (Exception e) {
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
+				}
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternNode_c_c_AnonIsUnnamed, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternNode_c_c_AnonIsUnnamed, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternNode::AnonIsUnnamed", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -652,44 +672,49 @@
 	 */
 	@Override
 	public boolean validateTypeIsRequired(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv TypeIsRequired:
-		 *   let severity : Integer[1] = 'RelPatternNode::TypeIsRequired'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let
-		 *         result : Boolean[?] = not isExpression() implies referredEClassifier <> null
-		 *       in
-		 *         'RelPatternNode::TypeIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternNode_c_c_TypeIsRequired);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @Nullable Object CAUGHT_result;
-			try {
-				final /*@NonInvalid*/ boolean isExpression = this.isExpression();
-				final /*@NonInvalid*/ java.lang.@Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-				final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = this.getReferredEClassifier();
-				final /*@NonInvalid*/ boolean ne = referredEClassifier != null;
-				final /*@Thrown*/ java.lang.@Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(not, ne);
-				CAUGHT_result = result;
+		try {
+			/**
+			 *
+			 * inv TypeIsRequired:
+			 *   let severity : Integer[1] = 'RelPatternNode::TypeIsRequired'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let
+			 *         result : Boolean[?] = not isExpression() implies referredEClassifier <> null
+			 *       in
+			 *         'RelPatternNode::TypeIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternNode_c_c_TypeIsRequired);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
+			else {
+				/*@Caught*/ @Nullable Object CAUGHT_result;
+				try {
+					final /*@NonInvalid*/ boolean isExpression = this.isExpression();
+					final /*@NonInvalid*/ @Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+					final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = this.getReferredEClassifier();
+					final /*@NonInvalid*/ boolean ne = referredEClassifier != null;
+					final /*@Thrown*/ @Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(not, ne);
+					CAUGHT_result = result;
+				}
+				catch (Exception e) {
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
+				}
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternNode_c_c_TypeIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternNode_c_c_TypeIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternNode::TypeIsRequired", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -699,112 +724,117 @@
 	 */
 	@Override
 	public boolean validateEClassifierIsInTypedModel(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv EClassifierIsInTypedModel:
-		 *   let
-		 *     severity : Integer[1] = 'RelPatternNode::EClassifierIsInTypedModel'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let
-		 *         result : Boolean[?] = not isExpression() implies
-		 *         let txTypedModelNode : TxTypedModelNode[?] = owningRelDomainNode.referredTxTypedModelNode
-		 *         in txTypedModelNode <> null implies
-		 *           txTypedModelNode.usedTxPackageNodes.referredEPackage.eClassifiers->includes(referredEClassifier)
-		 *       in
-		 *         'RelPatternNode::EClassifierIsInTypedModel'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternNode_c_c_EClassifierIsInTypedModel);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @Nullable Object CAUGHT_result;
-			try {
-				final /*@NonInvalid*/ boolean isExpression = this.isExpression();
-				final /*@NonInvalid*/ java.lang.@Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
-				/*@Caught*/ @NonNull Object CAUGHT_implies;
+		try {
+			/**
+			 *
+			 * inv EClassifierIsInTypedModel:
+			 *   let
+			 *     severity : Integer[1] = 'RelPatternNode::EClassifierIsInTypedModel'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let
+			 *         result : Boolean[?] = not isExpression() implies
+			 *         let txTypedModelNode : TxTypedModelNode[?] = owningRelDomainNode.referredTxTypedModelNode
+			 *         in txTypedModelNode <> null implies
+			 *           txTypedModelNode.usedTxPackageNodes.referredEPackage.eClassifiers->includes(referredEClassifier)
+			 *       in
+			 *         'RelPatternNode::EClassifierIsInTypedModel'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_RelPatternNode_c_c_EClassifierIsInTypedModel);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @Nullable Object CAUGHT_result;
 				try {
-					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelDomainNode owningRelDomainNode = this.getOwningRelDomainNode();
-					final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@Nullable TxTypedModelNode txTypedModelNode = owningRelDomainNode.getReferredTxTypedModelNode();
-					final /*@NonInvalid*/ boolean ne = txTypedModelNode != null;
-					/*@Thrown*/ boolean implies;
-					if (ne) {
-						if (txTypedModelNode == null) {
-							throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/qvt/2016/UMLX\'::TxTypedModelNode::usedTxPackageNodes\'");
-						}
+					final /*@NonInvalid*/ boolean isExpression = this.isExpression();
+					final /*@NonInvalid*/ @Nullable Boolean not = BooleanNotOperation.INSTANCE.evaluate(isExpression);
+					/*@Caught*/ @NonNull Object CAUGHT_implies;
+					try {
 						@SuppressWarnings("null")
-						final /*@Thrown*/ java.util.@NonNull List<TxPackageNode> usedTxPackageNodes = txTypedModelNode.getUsedTxPackageNodes();
-						final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_usedTxPackageNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxPackageNode, usedTxPackageNodes);
-						/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_EPackage);
-						@NonNull Iterator<Object> ITERATOR__1 = BOXED_usedTxPackageNodes.iterator();
-						/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue collect_0;
-						while (true) {
-							if (!ITERATOR__1.hasNext()) {
-								collect_0 = accumulator;
-								break;
+						final /*@NonInvalid*/ @NonNull RelDomainNode owningRelDomainNode = this.getOwningRelDomainNode();
+						final /*@NonInvalid*/ @Nullable TxTypedModelNode txTypedModelNode = owningRelDomainNode.getReferredTxTypedModelNode();
+						final /*@NonInvalid*/ boolean ne = txTypedModelNode != null;
+						/*@Thrown*/ boolean implies;
+						if (ne) {
+							if (txTypedModelNode == null) {
+								throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/qvt/2016/UMLX\'::TxTypedModelNode::usedTxPackageNodes\'");
 							}
 							@SuppressWarnings("null")
-							/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull TxPackageNode _1 = (TxPackageNode)ITERATOR__1.next();
-							/**
-							 * referredEPackage
-							 */
-							@SuppressWarnings("null")
-							final /*@NonInvalid*/ org.eclipse.emf.ecore.@NonNull EPackage referredEPackage = _1.getReferredEPackage();
-							//
-							accumulator.add(referredEPackage);
+							final /*@Thrown*/ @NonNull List<TxPackageNode> usedTxPackageNodes = txTypedModelNode.getUsedTxPackageNodes();
+							final /*@Thrown*/ @NonNull OrderedSetValue BOXED_usedTxPackageNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxPackageNode, usedTxPackageNodes);
+							/*@Thrown*/ @NonNull Accumulator accumulator = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_EPackage);
+							@NonNull Iterator<Object> ITERATOR__1 = BOXED_usedTxPackageNodes.iterator();
+							/*@Thrown*/ @NonNull SequenceValue collect_0;
+							while (true) {
+								if (!ITERATOR__1.hasNext()) {
+									collect_0 = accumulator;
+									break;
+								}
+								@SuppressWarnings("null")
+								/*@NonInvalid*/ @NonNull TxPackageNode _1 = (@NonNull TxPackageNode)ITERATOR__1.next();
+								/**
+								 * referredEPackage
+								 */
+								@SuppressWarnings("null")
+								final /*@NonInvalid*/ @NonNull EPackage referredEPackage = _1.getReferredEPackage();
+								//
+								accumulator.add(referredEPackage);
+							}
+							/*@Thrown*/ @NonNull Accumulator accumulator_0 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_EClassifier);
+							@NonNull Iterator<Object> ITERATOR__1_0 = collect_0.iterator();
+							/*@Thrown*/ @NonNull SequenceValue collect;
+							while (true) {
+								if (!ITERATOR__1_0.hasNext()) {
+									collect = accumulator_0;
+									break;
+								}
+								@SuppressWarnings("null")
+								/*@NonInvalid*/ @NonNull EPackage _1_0 = (@NonNull EPackage)ITERATOR__1_0.next();
+								/**
+								 * eClassifiers
+								 */
+								@SuppressWarnings("null")
+								final /*@NonInvalid*/ @NonNull List<EClassifier> eClassifiers = _1_0.getEClassifiers();
+								final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_eClassifiers = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClassifier, eClassifiers);
+								//
+								for (Object value : BOXED_eClassifiers.flatten().getElements()) {
+									accumulator_0.add(value);
+								}
+							}
+							final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = this.getReferredEClassifier();
+							final /*@Thrown*/ boolean includes = CollectionIncludesOperation.INSTANCE.evaluate(collect, referredEClassifier).booleanValue();
+							implies = includes;
 						}
-						/*@Thrown*/ SequenceValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_0 = ValueUtil.createSequenceAccumulatorValue(UMLXTables.SEQ_CLSSid_EClassifier);
-						@NonNull Iterator<Object> ITERATOR__1_0 = collect_0.iterator();
-						/*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SequenceValue collect;
-						while (true) {
-							if (!ITERATOR__1_0.hasNext()) {
-								collect = accumulator_0;
-								break;
-							}
-							@SuppressWarnings("null")
-							/*@NonInvalid*/ org.eclipse.emf.ecore.@NonNull EPackage _1_0 = (EPackage)ITERATOR__1_0.next();
-							/**
-							 * eClassifiers
-							 */
-							@SuppressWarnings("null")
-							final /*@NonInvalid*/ java.util.@NonNull List<EClassifier> eClassifiers = _1_0.getEClassifiers();
-							final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_eClassifiers = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClassifier, eClassifiers);
-							//
-							for (Object value : BOXED_eClassifiers.flatten().getElements()) {
-								accumulator_0.add(value);
-							}
+						else {
+							implies = ValueUtil.TRUE_VALUE;
 						}
-						final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = this.getReferredEClassifier();
-						final /*@Thrown*/ boolean includes = CollectionIncludesOperation.INSTANCE.evaluate(collect, referredEClassifier).booleanValue();
-						implies = includes;
+						CAUGHT_implies = implies;
 					}
-					else {
-						implies = ValueUtil.TRUE_VALUE;
+					catch (Exception e) {
+						CAUGHT_implies = ValueUtil.createInvalidValue(e);
 					}
-					CAUGHT_implies = implies;
+					final /*@Thrown*/ @Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(not, CAUGHT_implies);
+					CAUGHT_result = result;
 				}
 				catch (Exception e) {
-					CAUGHT_implies = ValueUtil.createInvalidValue(e);
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
 				}
-				final /*@Thrown*/ java.lang.@Nullable Boolean result = BooleanImpliesOperation.INSTANCE.evaluate(not, CAUGHT_implies);
-				CAUGHT_result = result;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternNode_c_c_EClassifierIsInTypedModel, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_RelPatternNode_c_c_EClassifierIsInTypedModel, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("RelPatternNode::EClassifierIsInTypedModel", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -815,7 +845,7 @@
 	@Override
 	public EList<RelInvocationEdge> getInvokingRelInvocationEdges() {
 		if (invokingRelInvocationEdges == null) {
-			invokingRelInvocationEdges = new EObjectWithInverseResolvingEList<RelInvocationEdge>(RelInvocationEdge.class, this, UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES, UMLXPackage.REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE);
+			invokingRelInvocationEdges = new EObjectWithInverseResolvingEList<RelInvocationEdge>(RelInvocationEdge.class, this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 9, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0);
 		}
 		return invokingRelInvocationEdges;
 	}
@@ -840,7 +870,7 @@
 		boolean oldIsAnon = isAnon;
 		isAnon = newIsAnon;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.REL_PATTERN_NODE__IS_ANON, oldIsAnon, isAnon));
+			eNotify(new ENotificationImpl(this, Notification.SET, RelNodeImpl.REL_NODE_FEATURE_COUNT + 10, oldIsAnon, isAnon));
 	}
 
 	/**
@@ -850,7 +880,29 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: ");
+		result.append(name);
+		result.append(", isMany: ");
+		result.append(isMany);
+		result.append(", isNullFree: ");
+		result.append(isNullFree);
+		result.append(", isOrdered: ");
+		result.append(isOrdered);
+		result.append(", isRequired: ");
+		result.append(isRequired);
+		result.append(", isUnique: ");
+		result.append(isUnique);
+		result.append(", initExpressionLines: ");
+		result.append(initExpressionLines);
+		result.append(", isAnon: ");
+		result.append(isAnon);
+		result.append(", isRoot: ");
+		result.append(isRoot);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -862,13 +914,13 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_NODE__INCOMING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 7:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getIncoming()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 9:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getInvokingRelInvocationEdges()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.REL_PATTERN_NODE__OUTGOING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 12:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOutgoing()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 13:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningRelDomainNode((RelDomainNode)otherEnd, msgs);
@@ -884,13 +936,13 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_NODE__INCOMING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 7:
 				return ((InternalEList<?>)getIncoming()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 9:
 				return ((InternalEList<?>)getInvokingRelInvocationEdges()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.REL_PATTERN_NODE__OUTGOING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 12:
 				return ((InternalEList<?>)getOutgoing()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 13:
 				return basicSetOwningRelDomainNode(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -904,8 +956,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES, RelDomainNode.class, msgs);
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 13:
+				return eInternalContainer().eInverseRemove(this, RelNodeImpl.REL_NODE_FEATURE_COUNT + 2, RelDomainNode.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -918,34 +970,34 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_NODE__NAME:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				return getName();
-			case UMLXPackage.REL_PATTERN_NODE__IS_MANY:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				return isIsMany();
-			case UMLXPackage.REL_PATTERN_NODE__IS_NULL_FREE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return isIsNullFree();
-			case UMLXPackage.REL_PATTERN_NODE__IS_ORDERED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				return isIsOrdered();
-			case UMLXPackage.REL_PATTERN_NODE__IS_REQUIRED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 4:
 				return isIsRequired();
-			case UMLXPackage.REL_PATTERN_NODE__IS_UNIQUE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 5:
 				return isIsUnique();
-			case UMLXPackage.REL_PATTERN_NODE__REFERRED_ECLASSIFIER:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 6:
 				if (resolve) return getReferredEClassifier();
 				return basicGetReferredEClassifier();
-			case UMLXPackage.REL_PATTERN_NODE__INCOMING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 7:
 				return getIncoming();
-			case UMLXPackage.REL_PATTERN_NODE__INIT_EXPRESSION_LINES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 8:
 				return getInitExpressionLines();
-			case UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 9:
 				return getInvokingRelInvocationEdges();
-			case UMLXPackage.REL_PATTERN_NODE__IS_ANON:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 10:
 				return isIsAnon();
-			case UMLXPackage.REL_PATTERN_NODE__IS_ROOT:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 11:
 				return isIsRoot();
-			case UMLXPackage.REL_PATTERN_NODE__OUTGOING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 12:
 				return getOutgoing();
-			case UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 13:
 				return getOwningRelDomainNode();
 		}
 		return super.eGet(featureID, resolve, coreType);
@@ -960,50 +1012,50 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_NODE__NAME:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				setName((String)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_MANY:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				setIsMany((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_NULL_FREE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				setIsNullFree((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_ORDERED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				setIsOrdered((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_REQUIRED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 4:
 				setIsRequired((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_UNIQUE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 5:
 				setIsUnique((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__REFERRED_ECLASSIFIER:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 6:
 				setReferredEClassifier((EClassifier)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__INCOMING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 7:
 				getIncoming().clear();
 				getIncoming().addAll((Collection<? extends RelPatternEdge>)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__INIT_EXPRESSION_LINES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 8:
 				getInitExpressionLines().clear();
 				getInitExpressionLines().addAll((Collection<? extends String>)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 9:
 				getInvokingRelInvocationEdges().clear();
 				getInvokingRelInvocationEdges().addAll((Collection<? extends RelInvocationEdge>)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_ANON:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 10:
 				setIsAnon((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_ROOT:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 11:
 				setIsRoot((Boolean)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__OUTGOING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 12:
 				getOutgoing().clear();
 				getOutgoing().addAll((Collection<? extends RelPatternEdge>)newValue);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 13:
 				setOwningRelDomainNode((RelDomainNode)newValue);
 				return;
 		}
@@ -1018,46 +1070,46 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_NODE__NAME:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				setName(NAME_EDEFAULT);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_MANY:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				setIsMany(IS_MANY_EDEFAULT);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_NULL_FREE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				setIsNullFree(IS_NULL_FREE_EDEFAULT);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_ORDERED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				setIsOrdered(IS_ORDERED_EDEFAULT);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_REQUIRED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 4:
 				setIsRequired(IS_REQUIRED_EDEFAULT);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_UNIQUE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 5:
 				setIsUnique(IS_UNIQUE_EDEFAULT);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__REFERRED_ECLASSIFIER:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 6:
 				setReferredEClassifier((EClassifier)null);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__INCOMING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 7:
 				getIncoming().clear();
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__INIT_EXPRESSION_LINES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 8:
 				getInitExpressionLines().clear();
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 9:
 				getInvokingRelInvocationEdges().clear();
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_ANON:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 10:
 				setIsAnon(IS_ANON_EDEFAULT);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__IS_ROOT:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 11:
 				setIsRoot(IS_ROOT_EDEFAULT);
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__OUTGOING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 12:
 				getOutgoing().clear();
 				return;
-			case UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 13:
 				setOwningRelDomainNode((RelDomainNode)null);
 				return;
 		}
@@ -1072,33 +1124,33 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.REL_PATTERN_NODE__NAME:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0:
 				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case UMLXPackage.REL_PATTERN_NODE__IS_MANY:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1:
 				return isMany != IS_MANY_EDEFAULT;
-			case UMLXPackage.REL_PATTERN_NODE__IS_NULL_FREE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2:
 				return isNullFree != IS_NULL_FREE_EDEFAULT;
-			case UMLXPackage.REL_PATTERN_NODE__IS_ORDERED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3:
 				return isOrdered != IS_ORDERED_EDEFAULT;
-			case UMLXPackage.REL_PATTERN_NODE__IS_REQUIRED:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 4:
 				return isRequired != IS_REQUIRED_EDEFAULT;
-			case UMLXPackage.REL_PATTERN_NODE__IS_UNIQUE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 5:
 				return isUnique != IS_UNIQUE_EDEFAULT;
-			case UMLXPackage.REL_PATTERN_NODE__REFERRED_ECLASSIFIER:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 6:
 				return referredEClassifier != null;
-			case UMLXPackage.REL_PATTERN_NODE__INCOMING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 7:
 				return incoming != null && !incoming.isEmpty();
-			case UMLXPackage.REL_PATTERN_NODE__INIT_EXPRESSION_LINES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 8:
 				return initExpressionLines != null && !initExpressionLines.isEmpty();
-			case UMLXPackage.REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 9:
 				return invokingRelInvocationEdges != null && !invokingRelInvocationEdges.isEmpty();
-			case UMLXPackage.REL_PATTERN_NODE__IS_ANON:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 10:
 				return isAnon != IS_ANON_EDEFAULT;
-			case UMLXPackage.REL_PATTERN_NODE__IS_ROOT:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 11:
 				return isRoot != IS_ROOT_EDEFAULT;
-			case UMLXPackage.REL_PATTERN_NODE__OUTGOING:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 12:
 				return outgoing != null && !outgoing.isEmpty();
-			case UMLXPackage.REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE:
+			case RelNodeImpl.REL_NODE_FEATURE_COUNT + 13:
 				return getOwningRelDomainNode() != null;
 		}
 		return super.eIsSet(featureID);
@@ -1113,18 +1165,18 @@
 	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
 		if (baseClass == UMLXNamedElement.class) {
 			switch (derivedFeatureID) {
-				case UMLXPackage.REL_PATTERN_NODE__NAME: return UMLXPackage.UMLX_NAMED_ELEMENT__NAME;
+				case RelNodeImpl.REL_NODE_FEATURE_COUNT + 0: return UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0;
 				default: return -1;
 			}
 		}
 		if (baseClass == UMLXTypedElement.class) {
 			switch (derivedFeatureID) {
-				case UMLXPackage.REL_PATTERN_NODE__IS_MANY: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY;
-				case UMLXPackage.REL_PATTERN_NODE__IS_NULL_FREE: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE;
-				case UMLXPackage.REL_PATTERN_NODE__IS_ORDERED: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED;
-				case UMLXPackage.REL_PATTERN_NODE__IS_REQUIRED: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED;
-				case UMLXPackage.REL_PATTERN_NODE__IS_UNIQUE: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE;
-				case UMLXPackage.REL_PATTERN_NODE__REFERRED_ECLASSIFIER: return UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER;
+				case RelNodeImpl.REL_NODE_FEATURE_COUNT + 1: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0;
+				case RelNodeImpl.REL_NODE_FEATURE_COUNT + 2: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1;
+				case RelNodeImpl.REL_NODE_FEATURE_COUNT + 3: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2;
+				case RelNodeImpl.REL_NODE_FEATURE_COUNT + 4: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3;
+				case RelNodeImpl.REL_NODE_FEATURE_COUNT + 5: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4;
+				case RelNodeImpl.REL_NODE_FEATURE_COUNT + 6: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5;
 				default: return -1;
 			}
 		}
@@ -1140,18 +1192,18 @@
 	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
 		if (baseClass == UMLXNamedElement.class) {
 			switch (baseFeatureID) {
-				case UMLXPackage.UMLX_NAMED_ELEMENT__NAME: return UMLXPackage.REL_PATTERN_NODE__NAME;
+				case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0: return RelNodeImpl.REL_NODE_FEATURE_COUNT + 0;
 				default: return -1;
 			}
 		}
 		if (baseClass == UMLXTypedElement.class) {
 			switch (baseFeatureID) {
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY: return UMLXPackage.REL_PATTERN_NODE__IS_MANY;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE: return UMLXPackage.REL_PATTERN_NODE__IS_NULL_FREE;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED: return UMLXPackage.REL_PATTERN_NODE__IS_ORDERED;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED: return UMLXPackage.REL_PATTERN_NODE__IS_REQUIRED;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE: return UMLXPackage.REL_PATTERN_NODE__IS_UNIQUE;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER: return UMLXPackage.REL_PATTERN_NODE__REFERRED_ECLASSIFIER;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0: return RelNodeImpl.REL_NODE_FEATURE_COUNT + 1;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1: return RelNodeImpl.REL_NODE_FEATURE_COUNT + 2;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2: return RelNodeImpl.REL_NODE_FEATURE_COUNT + 3;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3: return RelNodeImpl.REL_NODE_FEATURE_COUNT + 4;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4: return RelNodeImpl.REL_NODE_FEATURE_COUNT + 5;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5: return RelNodeImpl.REL_NODE_FEATURE_COUNT + 6;
 				default: return -1;
 			}
 		}
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxDiagramImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxDiagramImpl.java
index 6a145c4..e621da9 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxDiagramImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxDiagramImpl.java
@@ -13,6 +13,7 @@
 import java.util.Collection;
 
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
@@ -25,13 +26,17 @@
 import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.evaluation.Executor;
+import org.eclipse.ocl.pivot.ids.IdResolver;
 import org.eclipse.ocl.pivot.ids.TypeId;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.oclany.OclComparableLessThanEqualOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
-import org.eclipse.ocl.pivot.values.SetValue;
+import org.eclipse.ocl.pivot.values.IntegerValue;
+import org.eclipse.ocl.pivot.values.OrderedSetValue;
+import org.eclipse.ocl.pivot.values.SetValue.Accumulator;
 import org.eclipse.qvtd.umlx.RelDiagram;
 import org.eclipse.qvtd.umlx.TxDiagram;
 import org.eclipse.qvtd.umlx.TxKeyNode;
@@ -62,6 +67,15 @@
  */
 public class TxDiagramImpl extends UMLXNamedElementImpl implements TxDiagram {
 	/**
+	 * The number of structural features of the '<em>Tx Diagram</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int TX_DIAGRAM_FEATURE_COUNT = UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 6;
+
+	/**
 	 * The cached value of the '{@link #getOwnedRelDiagrams() <em>Owned Rel Diagrams</em>}' containment reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -156,7 +170,7 @@
 	@Override
 	public EList<RelDiagram> getOwnedRelDiagrams() {
 		if (ownedRelDiagrams == null) {
-			ownedRelDiagrams = new EObjectContainmentWithInverseEList<RelDiagram>(RelDiagram.class, this, UMLXPackage.TX_DIAGRAM__OWNED_REL_DIAGRAMS, UMLXPackage.REL_DIAGRAM__OWNING_TX_DIAGRAM);
+			ownedRelDiagrams = new EObjectContainmentWithInverseEList<RelDiagram>(RelDiagram.class, this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4);
 		}
 		return ownedRelDiagrams;
 	}
@@ -169,7 +183,7 @@
 	@Override
 	public EList<TxKeyNode> getOwnedTxKeyNodes() {
 		if (ownedTxKeyNodes == null) {
-			ownedTxKeyNodes = new EObjectContainmentWithInverseEList<TxKeyNode>(TxKeyNode.class, this, UMLXPackage.TX_DIAGRAM__OWNED_TX_KEY_NODES, UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM);
+			ownedTxKeyNodes = new EObjectContainmentWithInverseEList<TxKeyNode>(TxKeyNode.class, this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1);
 		}
 		return ownedTxKeyNodes;
 	}
@@ -182,7 +196,7 @@
 	@Override
 	public EList<TxPackageNode> getOwnedTxPackageNodes() {
 		if (ownedTxPackageNodes == null) {
-			ownedTxPackageNodes = new EObjectContainmentWithInverseEList<TxPackageNode>(TxPackageNode.class, this, UMLXPackage.TX_DIAGRAM__OWNED_TX_PACKAGE_NODES, UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM);
+			ownedTxPackageNodes = new EObjectContainmentWithInverseEList<TxPackageNode>(TxPackageNode.class, this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1);
 		}
 		return ownedTxPackageNodes;
 	}
@@ -195,7 +209,7 @@
 	@Override
 	public EList<TxQueryNode> getOwnedTxQueryNodes() {
 		if (ownedTxQueryNodes == null) {
-			ownedTxQueryNodes = new EObjectContainmentWithInverseEList<TxQueryNode>(TxQueryNode.class, this, UMLXPackage.TX_DIAGRAM__OWNED_TX_QUERY_NODES, UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM);
+			ownedTxQueryNodes = new EObjectContainmentWithInverseEList<TxQueryNode>(TxQueryNode.class, this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3, TxNodeImpl.TX_NODE_FEATURE_COUNT + 9);
 		}
 		return ownedTxQueryNodes;
 	}
@@ -208,7 +222,7 @@
 	@Override
 	public EList<TxTypedModelNode> getOwnedTxTypedModelNodes() {
 		if (ownedTxTypedModelNodes == null) {
-			ownedTxTypedModelNodes = new EObjectContainmentWithInverseEList<TxTypedModelNode>(TxTypedModelNode.class, this, UMLXPackage.TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES, UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM);
+			ownedTxTypedModelNodes = new EObjectContainmentWithInverseEList<TxTypedModelNode>(TxTypedModelNode.class, this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4, TxNodeImpl.TX_NODE_FEATURE_COUNT + 4);
 		}
 		return ownedTxTypedModelNodes;
 	}
@@ -233,7 +247,7 @@
 		String oldPackage = package_;
 		package_ = newPackage;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_DIAGRAM__PACKAGE, oldPackage, package_));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5, oldPackage, package_));
 	}
 
 	/**
@@ -243,66 +257,71 @@
 	 */
 	@Override
 	public boolean validateTxQueryNodeNamesAreUnique(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv TxQueryNodeNamesAreUnique:
-		 *   let
-		 *     severity : Integer[1] = 'TxDiagram::TxQueryNodeNamesAreUnique'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = ownedTxQueryNodes->isUnique(name)
-		 *       in
-		 *         'TxDiagram::TxQueryNodeNamesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxDiagram_c_c_TxQueryNodeNamesAreUnique);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_result;
-			try {
-				@SuppressWarnings("null")
-				final /*@NonInvalid*/ java.util.@NonNull List<TxQueryNode> ownedTxQueryNodes = this.getOwnedTxQueryNodes();
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedTxQueryNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxQueryNode, ownedTxQueryNodes);
-				/*@Thrown*/ SetValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxQueryNode);
-				@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedTxQueryNodes.iterator();
-				/*@Thrown*/ boolean result;
-				while (true) {
-					if (!ITERATOR__1.hasNext()) {
-						result = ValueUtil.TRUE_VALUE;
-						break;
-					}
+		try {
+			/**
+			 *
+			 * inv TxQueryNodeNamesAreUnique:
+			 *   let
+			 *     severity : Integer[1] = 'TxDiagram::TxQueryNodeNamesAreUnique'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = ownedTxQueryNodes->isUnique(name)
+			 *       in
+			 *         'TxDiagram::TxQueryNodeNamesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxDiagram_c_c_TxQueryNodeNamesAreUnique);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @NonNull Object CAUGHT_result;
+				try {
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull TxQueryNode _1 = (TxQueryNode)ITERATOR__1.next();
-					/**
-					 * name
-					 */
-					final /*@NonInvalid*/ java.lang.@Nullable String name = _1.getName();
-					//
-					if (accumulator.includes(name) == ValueUtil.TRUE_VALUE) {
-						result = ValueUtil.FALSE_VALUE;			// Abort after second find
-						break;
+					final /*@NonInvalid*/ @NonNull List<TxQueryNode> ownedTxQueryNodes = this.getOwnedTxQueryNodes();
+					final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedTxQueryNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxQueryNode, ownedTxQueryNodes);
+					/*@Thrown*/ @NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxQueryNode);
+					@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedTxQueryNodes.iterator();
+					/*@Thrown*/ boolean result;
+					while (true) {
+						if (!ITERATOR__1.hasNext()) {
+							result = ValueUtil.TRUE_VALUE;
+							break;
+						}
+						@SuppressWarnings("null")
+						/*@NonInvalid*/ @NonNull TxQueryNode _1 = (@NonNull TxQueryNode)ITERATOR__1.next();
+						/**
+						 * name
+						 */
+						final /*@NonInvalid*/ @Nullable String name = _1.getName();
+						//
+						if (accumulator.includes(name) == ValueUtil.TRUE_VALUE) {
+							result = ValueUtil.FALSE_VALUE;			// Abort after second find
+							break;
+						}
+						else {
+							accumulator.add(name);
+						}
 					}
-					else {
-						accumulator.add(name);
-					}
+					CAUGHT_result = result;
 				}
-				CAUGHT_result = result;
+				catch (Exception e) {
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
+				}
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxDiagram_c_c_TxQueryNodeNamesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxDiagram_c_c_TxQueryNodeNamesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxDiagram::TxQueryNodeNamesAreUnique", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -312,66 +331,71 @@
 	 */
 	@Override
 	public boolean validateRelDiagramNamesAreUnique(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv RelDiagramNamesAreUnique:
-		 *   let
-		 *     severity : Integer[1] = 'TxDiagram::RelDiagramNamesAreUnique'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = ownedRelDiagrams->isUnique(name)
-		 *       in
-		 *         'TxDiagram::RelDiagramNamesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxDiagram_c_c_RelDiagramNamesAreUnique);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_result;
-			try {
-				@SuppressWarnings("null")
-				final /*@NonInvalid*/ java.util.@NonNull List<RelDiagram> ownedRelDiagrams = this.getOwnedRelDiagrams();
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedRelDiagrams = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelDiagram, ownedRelDiagrams);
-				/*@Thrown*/ SetValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_RelDiagram);
-				@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedRelDiagrams.iterator();
-				/*@Thrown*/ boolean result;
-				while (true) {
-					if (!ITERATOR__1.hasNext()) {
-						result = ValueUtil.TRUE_VALUE;
-						break;
-					}
+		try {
+			/**
+			 *
+			 * inv RelDiagramNamesAreUnique:
+			 *   let
+			 *     severity : Integer[1] = 'TxDiagram::RelDiagramNamesAreUnique'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = ownedRelDiagrams->isUnique(name)
+			 *       in
+			 *         'TxDiagram::RelDiagramNamesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxDiagram_c_c_RelDiagramNamesAreUnique);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @NonNull Object CAUGHT_result;
+				try {
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull RelDiagram _1 = (RelDiagram)ITERATOR__1.next();
-					/**
-					 * name
-					 */
-					final /*@NonInvalid*/ java.lang.@Nullable String name = _1.getName();
-					//
-					if (accumulator.includes(name) == ValueUtil.TRUE_VALUE) {
-						result = ValueUtil.FALSE_VALUE;			// Abort after second find
-						break;
+					final /*@NonInvalid*/ @NonNull List<RelDiagram> ownedRelDiagrams = this.getOwnedRelDiagrams();
+					final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedRelDiagrams = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_RelDiagram, ownedRelDiagrams);
+					/*@Thrown*/ @NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_RelDiagram);
+					@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedRelDiagrams.iterator();
+					/*@Thrown*/ boolean result;
+					while (true) {
+						if (!ITERATOR__1.hasNext()) {
+							result = ValueUtil.TRUE_VALUE;
+							break;
+						}
+						@SuppressWarnings("null")
+						/*@NonInvalid*/ @NonNull RelDiagram _1 = (@NonNull RelDiagram)ITERATOR__1.next();
+						/**
+						 * name
+						 */
+						final /*@NonInvalid*/ @Nullable String name = _1.getName();
+						//
+						if (accumulator.includes(name) == ValueUtil.TRUE_VALUE) {
+							result = ValueUtil.FALSE_VALUE;			// Abort after second find
+							break;
+						}
+						else {
+							accumulator.add(name);
+						}
 					}
-					else {
-						accumulator.add(name);
-					}
+					CAUGHT_result = result;
 				}
-				CAUGHT_result = result;
+				catch (Exception e) {
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
+				}
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxDiagram_c_c_RelDiagramNamesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxDiagram_c_c_RelDiagramNamesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxDiagram::RelDiagramNamesAreUnique", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -381,33 +405,38 @@
 	 */
 	@Override
 	public boolean validateNameIsRequired(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv NameIsRequired:
-		 *   let severity : Integer[1] = 'TxDiagram::NameIsRequired'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = name <> null
-		 *       in
-		 *         'TxDiagram::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxDiagram_c_c_NameIsRequired);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv NameIsRequired:
+			 *   let severity : Integer[1] = 'TxDiagram::NameIsRequired'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = name <> null
+			 *       in
+			 *         'TxDiagram::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxDiagram_c_c_NameIsRequired);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				final /*@NonInvalid*/ @Nullable String name = this.getName();
+				final /*@NonInvalid*/ boolean result = name != null;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxDiagram_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			final /*@NonInvalid*/ java.lang.@Nullable String name = this.getName();
-			final /*@NonInvalid*/ boolean result = name != null;
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxDiagram_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxDiagram::NameIsRequired", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -417,66 +446,71 @@
 	 */
 	@Override
 	public boolean validateTxTypedModelNodeNamesAreUnique(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv TxTypedModelNodeNamesAreUnique:
-		 *   let
-		 *     severity : Integer[1] = 'TxDiagram::TxTypedModelNodeNamesAreUnique'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = ownedTxTypedModelNodes->isUnique(name)
-		 *       in
-		 *         'TxDiagram::TxTypedModelNodeNamesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxDiagram_c_c_TxTypedModelNodeNamesAreUnique);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_result;
-			try {
-				@SuppressWarnings("null")
-				final /*@NonInvalid*/ java.util.@NonNull List<TxTypedModelNode> ownedTxTypedModelNodes = this.getOwnedTxTypedModelNodes();
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedTxTypedModelNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxTypedModelNode, ownedTxTypedModelNodes);
-				/*@Thrown*/ SetValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxTypedModelNode);
-				@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedTxTypedModelNodes.iterator();
-				/*@Thrown*/ boolean result;
-				while (true) {
-					if (!ITERATOR__1.hasNext()) {
-						result = ValueUtil.TRUE_VALUE;
-						break;
-					}
+		try {
+			/**
+			 *
+			 * inv TxTypedModelNodeNamesAreUnique:
+			 *   let
+			 *     severity : Integer[1] = 'TxDiagram::TxTypedModelNodeNamesAreUnique'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = ownedTxTypedModelNodes->isUnique(name)
+			 *       in
+			 *         'TxDiagram::TxTypedModelNodeNamesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxDiagram_c_c_TxTypedModelNodeNamesAreUnique);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @NonNull Object CAUGHT_result;
+				try {
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull TxTypedModelNode _1 = (TxTypedModelNode)ITERATOR__1.next();
-					/**
-					 * name
-					 */
-					final /*@NonInvalid*/ java.lang.@Nullable String name = _1.getName();
-					//
-					if (accumulator.includes(name) == ValueUtil.TRUE_VALUE) {
-						result = ValueUtil.FALSE_VALUE;			// Abort after second find
-						break;
+					final /*@NonInvalid*/ @NonNull List<TxTypedModelNode> ownedTxTypedModelNodes = this.getOwnedTxTypedModelNodes();
+					final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedTxTypedModelNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxTypedModelNode, ownedTxTypedModelNodes);
+					/*@Thrown*/ @NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxTypedModelNode);
+					@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedTxTypedModelNodes.iterator();
+					/*@Thrown*/ boolean result;
+					while (true) {
+						if (!ITERATOR__1.hasNext()) {
+							result = ValueUtil.TRUE_VALUE;
+							break;
+						}
+						@SuppressWarnings("null")
+						/*@NonInvalid*/ @NonNull TxTypedModelNode _1 = (@NonNull TxTypedModelNode)ITERATOR__1.next();
+						/**
+						 * name
+						 */
+						final /*@NonInvalid*/ @Nullable String name = _1.getName();
+						//
+						if (accumulator.includes(name) == ValueUtil.TRUE_VALUE) {
+							result = ValueUtil.FALSE_VALUE;			// Abort after second find
+							break;
+						}
+						else {
+							accumulator.add(name);
+						}
 					}
-					else {
-						accumulator.add(name);
-					}
+					CAUGHT_result = result;
 				}
-				CAUGHT_result = result;
+				catch (Exception e) {
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
+				}
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxDiagram_c_c_TxTypedModelNodeNamesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxDiagram_c_c_TxTypedModelNodeNamesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxDiagram::TxTypedModelNodeNamesAreUnique", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -486,7 +520,13 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (package: ");
+		result.append(package_);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -498,15 +538,15 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_DIAGRAM__OWNED_REL_DIAGRAMS:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedRelDiagrams()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_KEY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedTxKeyNodes()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_PACKAGE_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedTxPackageNodes()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_QUERY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedTxQueryNodes()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedTxTypedModelNodes()).basicAdd(otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
@@ -520,15 +560,15 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_DIAGRAM__OWNED_REL_DIAGRAMS:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				return ((InternalEList<?>)getOwnedRelDiagrams()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_KEY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				return ((InternalEList<?>)getOwnedTxKeyNodes()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_PACKAGE_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return ((InternalEList<?>)getOwnedTxPackageNodes()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_QUERY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return ((InternalEList<?>)getOwnedTxQueryNodes()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				return ((InternalEList<?>)getOwnedTxTypedModelNodes()).basicRemove(otherEnd, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -542,17 +582,17 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.TX_DIAGRAM__OWNED_REL_DIAGRAMS:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				return getOwnedRelDiagrams();
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_KEY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				return getOwnedTxKeyNodes();
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_PACKAGE_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return getOwnedTxPackageNodes();
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_QUERY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return getOwnedTxQueryNodes();
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				return getOwnedTxTypedModelNodes();
-			case UMLXPackage.TX_DIAGRAM__PACKAGE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5:
 				return getPackage();
 		}
 		return super.eGet(featureID, resolve, coreType);
@@ -567,27 +607,27 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.TX_DIAGRAM__OWNED_REL_DIAGRAMS:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				getOwnedRelDiagrams().clear();
 				getOwnedRelDiagrams().addAll((Collection<? extends RelDiagram>)newValue);
 				return;
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_KEY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				getOwnedTxKeyNodes().clear();
 				getOwnedTxKeyNodes().addAll((Collection<? extends TxKeyNode>)newValue);
 				return;
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_PACKAGE_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				getOwnedTxPackageNodes().clear();
 				getOwnedTxPackageNodes().addAll((Collection<? extends TxPackageNode>)newValue);
 				return;
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_QUERY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				getOwnedTxQueryNodes().clear();
 				getOwnedTxQueryNodes().addAll((Collection<? extends TxQueryNode>)newValue);
 				return;
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				getOwnedTxTypedModelNodes().clear();
 				getOwnedTxTypedModelNodes().addAll((Collection<? extends TxTypedModelNode>)newValue);
 				return;
-			case UMLXPackage.TX_DIAGRAM__PACKAGE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5:
 				setPackage((String)newValue);
 				return;
 		}
@@ -602,22 +642,22 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_DIAGRAM__OWNED_REL_DIAGRAMS:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				getOwnedRelDiagrams().clear();
 				return;
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_KEY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				getOwnedTxKeyNodes().clear();
 				return;
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_PACKAGE_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				getOwnedTxPackageNodes().clear();
 				return;
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_QUERY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				getOwnedTxQueryNodes().clear();
 				return;
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				getOwnedTxTypedModelNodes().clear();
 				return;
-			case UMLXPackage.TX_DIAGRAM__PACKAGE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5:
 				setPackage(PACKAGE_EDEFAULT);
 				return;
 		}
@@ -632,17 +672,17 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_DIAGRAM__OWNED_REL_DIAGRAMS:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				return ownedRelDiagrams != null && !ownedRelDiagrams.isEmpty();
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_KEY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				return ownedTxKeyNodes != null && !ownedTxKeyNodes.isEmpty();
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_PACKAGE_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return ownedTxPackageNodes != null && !ownedTxPackageNodes.isEmpty();
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_QUERY_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return ownedTxQueryNodes != null && !ownedTxQueryNodes.isEmpty();
-			case UMLXPackage.TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				return ownedTxTypedModelNodes != null && !ownedTxTypedModelNodes.isEmpty();
-			case UMLXPackage.TX_DIAGRAM__PACKAGE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5:
 				return PACKAGE_EDEFAULT == null ? package_ != null : !PACKAGE_EDEFAULT.equals(package_);
 		}
 		return super.eIsSet(featureID);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxKeyNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxKeyNodeImpl.java
index 532e5f0..28d0eaa 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxKeyNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxKeyNodeImpl.java
@@ -13,25 +13,31 @@
 import java.util.Collection;
 
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.ocl.pivot.evaluation.Executor;
+import org.eclipse.ocl.pivot.ids.IdResolver;
 import org.eclipse.ocl.pivot.ids.TypeId;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.oclany.OclComparableLessThanEqualOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
-import org.eclipse.ocl.pivot.values.SetValue;
+import org.eclipse.ocl.pivot.values.IntegerValue;
+import org.eclipse.ocl.pivot.values.OrderedSetValue;
+import org.eclipse.ocl.pivot.values.SetValue.Accumulator;
 import org.eclipse.qvtd.umlx.TxDiagram;
 import org.eclipse.qvtd.umlx.TxKeyNode;
 import org.eclipse.qvtd.umlx.TxPartNode;
@@ -56,6 +62,15 @@
  */
 public class TxKeyNodeImpl extends TxNodeImpl implements TxKeyNode {
 	/**
+	 * The number of structural features of the '<em>Tx Key Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int TX_KEY_NODE_FEATURE_COUNT = TxNodeImpl.TX_NODE_FEATURE_COUNT + 3;
+
+	/**
 	 * The cached value of the '{@link #getOwnedTxPartNodes() <em>Owned Tx Part Nodes</em>}' containment reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -102,7 +117,7 @@
 	@Override
 	public EList<TxPartNode> getOwnedTxPartNodes() {
 		if (ownedTxPartNodes == null) {
-			ownedTxPartNodes = new EObjectContainmentWithInverseEList<TxPartNode>(TxPartNode.class, this, UMLXPackage.TX_KEY_NODE__OWNED_TX_PART_NODES, UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE);
+			ownedTxPartNodes = new EObjectContainmentWithInverseEList<TxPartNode>(TxPartNode.class, this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0);
 		}
 		return ownedTxPartNodes;
 	}
@@ -114,7 +129,7 @@
 	 */
 	@Override
 	public TxDiagram getOwningTxDiagram() {
-		if (eContainerFeatureID() != UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM) return null;
+		if (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 1)) return null;
 		return (TxDiagram)eInternalContainer();
 	}
 
@@ -124,7 +139,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningTxDiagram(TxDiagram newOwningTxDiagram, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1, msgs);
 		return msgs;
 	}
 
@@ -135,19 +150,19 @@
 	 */
 	@Override
 	public void setOwningTxDiagram(TxDiagram newOwningTxDiagram) {
-		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM && newOwningTxDiagram != null)) {
+		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 1) && newOwningTxDiagram != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningTxDiagram))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningTxDiagram != null)
-				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXPackage.TX_DIAGRAM__OWNED_TX_KEY_NODES, TxDiagram.class, msgs);
+				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1, TxDiagram.class, msgs);
 			msgs = basicSetOwningTxDiagram(newOwningTxDiagram, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM, newOwningTxDiagram, newOwningTxDiagram));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1, newOwningTxDiagram, newOwningTxDiagram));
 	}
 
 	/**
@@ -162,7 +177,7 @@
 			referredEClass = (EClass)eResolveProxy(oldReferredEClass);
 			if (referredEClass != oldReferredEClass) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.TX_KEY_NODE__REFERRED_ECLASS, oldReferredEClass, referredEClass));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2, oldReferredEClass, referredEClass));
 			}
 		}
 		return referredEClass;
@@ -187,7 +202,7 @@
 		EClass oldReferredEClass = referredEClass;
 		referredEClass = newReferredEClass;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_KEY_NODE__REFERRED_ECLASS, oldReferredEClass, referredEClass));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2, oldReferredEClass, referredEClass));
 	}
 
 	/**
@@ -197,49 +212,48 @@
 	 */
 	@Override
 	public boolean validatePartsAreUnique(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv PartsAreUnique:
-		 *   let severity : Integer[1] = 'TxKeyNode::PartsAreUnique'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let
-		 *         result : Boolean[1] = ownedTxPartNodes->isUnique(referredEStructuralFeature)
-		 *       in
-		 *         'TxKeyNode::PartsAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxKeyNode_c_c_PartsAreUnique);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_result;
-			try {
+		try {
+			/**
+			 *
+			 * inv PartsAreUnique:
+			 *   let severity : Integer[1] = 'TxKeyNode::PartsAreUnique'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let
+			 *         result : Boolean[1] = ownedTxPartNodes->isUnique(referredEStructuralFeature)
+			 *       in
+			 *         'TxKeyNode::PartsAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxKeyNode_c_c_PartsAreUnique);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
 				@SuppressWarnings("null")
-				final /*@NonInvalid*/ java.util.@NonNull List<TxPartNode> ownedTxPartNodes = this.getOwnedTxPartNodes();
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedTxPartNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxPartNode, ownedTxPartNodes);
-				/*@Thrown*/ SetValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxPartNode);
+				final /*@NonInvalid*/ @NonNull List<TxPartNode> ownedTxPartNodes = this.getOwnedTxPartNodes();
+				final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedTxPartNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxPartNode, ownedTxPartNodes);
+				/*@Thrown*/ @NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxPartNode);
 				@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedTxPartNodes.iterator();
-				/*@Thrown*/ boolean result;
+				/*@NonInvalid*/ boolean result;
 				while (true) {
 					if (!ITERATOR__1.hasNext()) {
 						result = ValueUtil.TRUE_VALUE;
 						break;
 					}
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull TxPartNode _1 = (TxPartNode)ITERATOR__1.next();
+					/*@NonInvalid*/ @NonNull TxPartNode _1 = (@NonNull TxPartNode)ITERATOR__1.next();
 					/**
 					 * referredEStructuralFeature
 					 */
 					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.emf.ecore.@NonNull EStructuralFeature referredEStructuralFeature = _1.getReferredEStructuralFeature();
+					final /*@NonInvalid*/ @NonNull EStructuralFeature referredEStructuralFeature = _1.getReferredEStructuralFeature();
 					//
 					if (accumulator.includes(referredEStructuralFeature) == ValueUtil.TRUE_VALUE) {
 						result = ValueUtil.FALSE_VALUE;			// Abort after second find
@@ -249,15 +263,14 @@
 						accumulator.add(referredEStructuralFeature);
 					}
 				}
-				CAUGHT_result = result;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxKeyNode_c_c_PartsAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxKeyNode_c_c_PartsAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxKeyNode::PartsAreUnique", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -269,9 +282,9 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_KEY_NODE__OWNED_TX_PART_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedTxPartNodes()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningTxDiagram((TxDiagram)otherEnd, msgs);
@@ -287,9 +300,9 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_KEY_NODE__OWNED_TX_PART_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return ((InternalEList<?>)getOwnedTxPartNodes()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return basicSetOwningTxDiagram(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -303,8 +316,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.TX_DIAGRAM__OWNED_TX_KEY_NODES, TxDiagram.class, msgs);
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
+				return eInternalContainer().eInverseRemove(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1, TxDiagram.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -317,11 +330,11 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.TX_KEY_NODE__OWNED_TX_PART_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return getOwnedTxPartNodes();
-			case UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return getOwningTxDiagram();
-			case UMLXPackage.TX_KEY_NODE__REFERRED_ECLASS:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				if (resolve) return getReferredEClass();
 				return basicGetReferredEClass();
 		}
@@ -337,14 +350,14 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.TX_KEY_NODE__OWNED_TX_PART_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				getOwnedTxPartNodes().clear();
 				getOwnedTxPartNodes().addAll((Collection<? extends TxPartNode>)newValue);
 				return;
-			case UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setOwningTxDiagram((TxDiagram)newValue);
 				return;
-			case UMLXPackage.TX_KEY_NODE__REFERRED_ECLASS:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setReferredEClass((EClass)newValue);
 				return;
 		}
@@ -359,13 +372,13 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_KEY_NODE__OWNED_TX_PART_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				getOwnedTxPartNodes().clear();
 				return;
-			case UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setOwningTxDiagram((TxDiagram)null);
 				return;
-			case UMLXPackage.TX_KEY_NODE__REFERRED_ECLASS:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setReferredEClass((EClass)null);
 				return;
 		}
@@ -380,11 +393,11 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_KEY_NODE__OWNED_TX_PART_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return ownedTxPartNodes != null && !ownedTxPartNodes.isEmpty();
-			case UMLXPackage.TX_KEY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return getOwningTxDiagram() != null;
-			case UMLXPackage.TX_KEY_NODE__REFERRED_ECLASS:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				return referredEClass != null;
 		}
 		return super.eIsSet(featureID);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxNodeImpl.java
index 2e60c47..38c3233 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxNodeImpl.java
@@ -25,6 +25,15 @@
  */
 public class TxNodeImpl extends UMLXElementImpl implements TxNode {
 	/**
+	 * The number of structural features of the '<em>Tx Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int TX_NODE_FEATURE_COUNT = UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0;
+
+	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxPackageNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxPackageNodeImpl.java
index a64088c..63eb740 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxPackageNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxPackageNodeImpl.java
@@ -43,6 +43,14 @@
  */
 public class TxPackageNodeImpl extends TxNodeImpl implements TxPackageNode {
 	/**
+	 * The number of structural features of the '<em>Tx Package Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int TX_PACKAGE_NODE_FEATURE_COUNT = TxNodeImpl.TX_NODE_FEATURE_COUNT + 3;
+	/**
 	 * The cached value of the '{@link #getImportAliases() <em>Import Aliases</em>}' attribute list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -87,7 +95,7 @@
 	@Override
 	public EList<String> getImportAliases() {
 		if (importAliases == null) {
-			importAliases = new EDataTypeUniqueEList<String>(String.class, this, UMLXPackage.TX_PACKAGE_NODE__IMPORT_ALIASES);
+			importAliases = new EDataTypeUniqueEList<String>(String.class, this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0);
 		}
 		return importAliases;
 	}
@@ -99,7 +107,7 @@
 	 */
 	@Override
 	public TxDiagram getOwningTxDiagram() {
-		if (eContainerFeatureID() != UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM) return null;
+		if (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 1)) return null;
 		return (TxDiagram)eInternalContainer();
 	}
 
@@ -109,7 +117,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningTxDiagram(TxDiagram newOwningTxDiagram, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1, msgs);
 		return msgs;
 	}
 
@@ -120,19 +128,19 @@
 	 */
 	@Override
 	public void setOwningTxDiagram(TxDiagram newOwningTxDiagram) {
-		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM && newOwningTxDiagram != null)) {
+		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 1) && newOwningTxDiagram != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningTxDiagram))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningTxDiagram != null)
-				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXPackage.TX_DIAGRAM__OWNED_TX_PACKAGE_NODES, TxDiagram.class, msgs);
+				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2, TxDiagram.class, msgs);
 			msgs = basicSetOwningTxDiagram(newOwningTxDiagram, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM, newOwningTxDiagram, newOwningTxDiagram));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1, newOwningTxDiagram, newOwningTxDiagram));
 	}
 
 	/**
@@ -147,7 +155,7 @@
 			referredEPackage = (EPackage)eResolveProxy(oldReferredEPackage);
 			if (referredEPackage != oldReferredEPackage) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.TX_PACKAGE_NODE__REFERRED_EPACKAGE, oldReferredEPackage, referredEPackage));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2, oldReferredEPackage, referredEPackage));
 			}
 		}
 		return referredEPackage;
@@ -172,7 +180,7 @@
 		EPackage oldReferredEPackage = referredEPackage;
 		referredEPackage = newReferredEPackage;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PACKAGE_NODE__REFERRED_EPACKAGE, oldReferredEPackage, referredEPackage));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2, oldReferredEPackage, referredEPackage));
 	}
 
 	/**
@@ -182,7 +190,13 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (importAliases: ");
+		result.append(importAliases);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -193,7 +207,7 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningTxDiagram((TxDiagram)otherEnd, msgs);
@@ -209,7 +223,7 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return basicSetOwningTxDiagram(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -223,8 +237,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.TX_DIAGRAM__OWNED_TX_PACKAGE_NODES, TxDiagram.class, msgs);
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
+				return eInternalContainer().eInverseRemove(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2, TxDiagram.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -237,11 +251,11 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.TX_PACKAGE_NODE__IMPORT_ALIASES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return getImportAliases();
-			case UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return getOwningTxDiagram();
-			case UMLXPackage.TX_PACKAGE_NODE__REFERRED_EPACKAGE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				if (resolve) return getReferredEPackage();
 				return basicGetReferredEPackage();
 		}
@@ -257,14 +271,14 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.TX_PACKAGE_NODE__IMPORT_ALIASES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				getImportAliases().clear();
 				getImportAliases().addAll((Collection<? extends String>)newValue);
 				return;
-			case UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setOwningTxDiagram((TxDiagram)newValue);
 				return;
-			case UMLXPackage.TX_PACKAGE_NODE__REFERRED_EPACKAGE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setReferredEPackage((EPackage)newValue);
 				return;
 		}
@@ -279,13 +293,13 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_PACKAGE_NODE__IMPORT_ALIASES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				getImportAliases().clear();
 				return;
-			case UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setOwningTxDiagram((TxDiagram)null);
 				return;
-			case UMLXPackage.TX_PACKAGE_NODE__REFERRED_EPACKAGE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setReferredEPackage((EPackage)null);
 				return;
 		}
@@ -300,11 +314,11 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_PACKAGE_NODE__IMPORT_ALIASES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return importAliases != null && !importAliases.isEmpty();
-			case UMLXPackage.TX_PACKAGE_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return getOwningTxDiagram() != null;
-			case UMLXPackage.TX_PACKAGE_NODE__REFERRED_EPACKAGE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				return referredEPackage != null;
 		}
 		return super.eIsSet(featureID);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxParameterNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxParameterNodeImpl.java
index 2a78610..b16e5a9 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxParameterNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxParameterNodeImpl.java
@@ -26,12 +26,14 @@
 import org.eclipse.jdt.annotation.NonNull;
 
 import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.evaluation.Executor;
 import org.eclipse.ocl.pivot.ids.TypeId;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.oclany.OclComparableLessThanEqualOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
+import org.eclipse.ocl.pivot.values.IntegerValue;
 import org.eclipse.qvtd.umlx.TxParameterNode;
 import org.eclipse.qvtd.umlx.TxQueryNode;
 import org.eclipse.qvtd.umlx.UMLXNamedElement;
@@ -63,6 +65,15 @@
  */
 public class TxParameterNodeImpl extends TxNodeImpl implements TxParameterNode {
 	/**
+	 * The number of structural features of the '<em>Tx Parameter Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int TX_PARAMETER_NODE_FEATURE_COUNT = TxNodeImpl.TX_NODE_FEATURE_COUNT + 8;
+
+	/**
 	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -231,7 +242,7 @@
 		String oldName = name;
 		name = newName;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PARAMETER_NODE__NAME, oldName, name));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0, oldName, name));
 	}
 
 	/**
@@ -254,7 +265,7 @@
 		boolean oldIsMany = isMany;
 		isMany = newIsMany;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PARAMETER_NODE__IS_MANY, oldIsMany, isMany));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1, oldIsMany, isMany));
 	}
 
 	/**
@@ -277,7 +288,7 @@
 		boolean oldIsNullFree = isNullFree;
 		isNullFree = newIsNullFree;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PARAMETER_NODE__IS_NULL_FREE, oldIsNullFree, isNullFree));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2, oldIsNullFree, isNullFree));
 	}
 
 	/**
@@ -300,7 +311,7 @@
 		boolean oldIsOrdered = isOrdered;
 		isOrdered = newIsOrdered;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PARAMETER_NODE__IS_ORDERED, oldIsOrdered, isOrdered));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 3, oldIsOrdered, isOrdered));
 	}
 
 	/**
@@ -323,7 +334,7 @@
 		boolean oldIsRequired = isRequired;
 		isRequired = newIsRequired;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PARAMETER_NODE__IS_REQUIRED, oldIsRequired, isRequired));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 4, oldIsRequired, isRequired));
 	}
 
 	/**
@@ -346,7 +357,7 @@
 		boolean oldIsUnique = isUnique;
 		isUnique = newIsUnique;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PARAMETER_NODE__IS_UNIQUE, oldIsUnique, isUnique));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 5, oldIsUnique, isUnique));
 	}
 
 	/**
@@ -361,7 +372,7 @@
 			referredEClassifier = (EClassifier)eResolveProxy(oldReferredEClassifier);
 			if (referredEClassifier != oldReferredEClassifier) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.TX_PARAMETER_NODE__REFERRED_ECLASSIFIER, oldReferredEClassifier, referredEClassifier));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, TxNodeImpl.TX_NODE_FEATURE_COUNT + 6, oldReferredEClassifier, referredEClassifier));
 			}
 		}
 		return referredEClassifier;
@@ -386,7 +397,7 @@
 		EClassifier oldReferredEClassifier = referredEClassifier;
 		referredEClassifier = newReferredEClassifier;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PARAMETER_NODE__REFERRED_ECLASSIFIER, oldReferredEClassifier, referredEClassifier));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 6, oldReferredEClassifier, referredEClassifier));
 	}
 
 	/**
@@ -396,7 +407,7 @@
 	 */
 	@Override
 	public TxQueryNode getOwningTxQueryNode() {
-		if (eContainerFeatureID() != UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE) return null;
+		if (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 7)) return null;
 		return (TxQueryNode)eInternalContainer();
 	}
 
@@ -406,7 +417,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningTxQueryNode(TxQueryNode newOwningTxQueryNode, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningTxQueryNode, UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningTxQueryNode, TxNodeImpl.TX_NODE_FEATURE_COUNT + 7, msgs);
 		return msgs;
 	}
 
@@ -417,19 +428,19 @@
 	 */
 	@Override
 	public void setOwningTxQueryNode(TxQueryNode newOwningTxQueryNode) {
-		if (newOwningTxQueryNode != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE && newOwningTxQueryNode != null)) {
+		if (newOwningTxQueryNode != eInternalContainer() || (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 7) && newOwningTxQueryNode != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningTxQueryNode))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningTxQueryNode != null)
-				msgs = ((InternalEObject)newOwningTxQueryNode).eInverseAdd(this, UMLXPackage.TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES, TxQueryNode.class, msgs);
+				msgs = ((InternalEObject)newOwningTxQueryNode).eInverseAdd(this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 8, TxQueryNode.class, msgs);
 			msgs = basicSetOwningTxQueryNode(newOwningTxQueryNode, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE, newOwningTxQueryNode, newOwningTxQueryNode));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 7, newOwningTxQueryNode, newOwningTxQueryNode));
 	}
 
 	/**
@@ -439,33 +450,38 @@
 	 */
 	@Override
 	public boolean validateNameIsRequired(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv NameIsRequired:
-		 *   let severity : Integer[1] = 'TxParameterNode::NameIsRequired'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = name <> null
-		 *       in
-		 *         'TxParameterNode::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxParameterNode_c_c_NameIsRequired);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv NameIsRequired:
+			 *   let severity : Integer[1] = 'TxParameterNode::NameIsRequired'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = name <> null
+			 *       in
+			 *         'TxParameterNode::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxParameterNode_c_c_NameIsRequired);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				final /*@NonInvalid*/ @Nullable String name = this.getName();
+				final /*@NonInvalid*/ boolean result = name != null;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxParameterNode_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			final /*@NonInvalid*/ java.lang.@Nullable String name = this.getName();
-			final /*@NonInvalid*/ boolean result = name != null;
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxParameterNode_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxParameterNode::NameIsRequired", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -475,33 +491,38 @@
 	 */
 	@Override
 	public boolean validateTypeIsRequired(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv TypeIsRequired:
-		 *   let severity : Integer[1] = 'TxParameterNode::TypeIsRequired'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = referredEClassifier <> null
-		 *       in
-		 *         'TxParameterNode::TypeIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxParameterNode_c_c_TypeIsRequired);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv TypeIsRequired:
+			 *   let severity : Integer[1] = 'TxParameterNode::TypeIsRequired'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = referredEClassifier <> null
+			 *       in
+			 *         'TxParameterNode::TypeIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxParameterNode_c_c_TypeIsRequired);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = this.getReferredEClassifier();
+				final /*@NonInvalid*/ boolean result = referredEClassifier != null;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxParameterNode_c_c_TypeIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = this.getReferredEClassifier();
-			final /*@NonInvalid*/ boolean result = referredEClassifier != null;
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxParameterNode_c_c_TypeIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxParameterNode::TypeIsRequired", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -511,7 +532,23 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: ");
+		result.append(name);
+		result.append(", isMany: ");
+		result.append(isMany);
+		result.append(", isNullFree: ");
+		result.append(isNullFree);
+		result.append(", isOrdered: ");
+		result.append(isOrdered);
+		result.append(", isRequired: ");
+		result.append(isRequired);
+		result.append(", isUnique: ");
+		result.append(isUnique);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -522,7 +559,7 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningTxQueryNode((TxQueryNode)otherEnd, msgs);
@@ -538,7 +575,7 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				return basicSetOwningTxQueryNode(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -552,8 +589,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES, TxQueryNode.class, msgs);
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
+				return eInternalContainer().eInverseRemove(this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 8, TxQueryNode.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -566,22 +603,22 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.TX_PARAMETER_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return getName();
-			case UMLXPackage.TX_PARAMETER_NODE__IS_MANY:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return isIsMany();
-			case UMLXPackage.TX_PARAMETER_NODE__IS_NULL_FREE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				return isIsNullFree();
-			case UMLXPackage.TX_PARAMETER_NODE__IS_ORDERED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				return isIsOrdered();
-			case UMLXPackage.TX_PARAMETER_NODE__IS_REQUIRED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				return isIsRequired();
-			case UMLXPackage.TX_PARAMETER_NODE__IS_UNIQUE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				return isIsUnique();
-			case UMLXPackage.TX_PARAMETER_NODE__REFERRED_ECLASSIFIER:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6:
 				if (resolve) return getReferredEClassifier();
 				return basicGetReferredEClassifier();
-			case UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				return getOwningTxQueryNode();
 		}
 		return super.eGet(featureID, resolve, coreType);
@@ -595,28 +632,28 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.TX_PARAMETER_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				setName((String)newValue);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_MANY:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setIsMany((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_NULL_FREE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setIsNullFree((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_ORDERED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				setIsOrdered((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_REQUIRED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				setIsRequired((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_UNIQUE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				setIsUnique((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__REFERRED_ECLASSIFIER:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6:
 				setReferredEClassifier((EClassifier)newValue);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				setOwningTxQueryNode((TxQueryNode)newValue);
 				return;
 		}
@@ -631,28 +668,28 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_PARAMETER_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				setName(NAME_EDEFAULT);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_MANY:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setIsMany(IS_MANY_EDEFAULT);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_NULL_FREE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setIsNullFree(IS_NULL_FREE_EDEFAULT);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_ORDERED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				setIsOrdered(IS_ORDERED_EDEFAULT);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_REQUIRED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				setIsRequired(IS_REQUIRED_EDEFAULT);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_UNIQUE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				setIsUnique(IS_UNIQUE_EDEFAULT);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__REFERRED_ECLASSIFIER:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6:
 				setReferredEClassifier((EClassifier)null);
 				return;
-			case UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				setOwningTxQueryNode((TxQueryNode)null);
 				return;
 		}
@@ -667,21 +704,21 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_PARAMETER_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case UMLXPackage.TX_PARAMETER_NODE__IS_MANY:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return isMany != IS_MANY_EDEFAULT;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_NULL_FREE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				return isNullFree != IS_NULL_FREE_EDEFAULT;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_ORDERED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				return isOrdered != IS_ORDERED_EDEFAULT;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_REQUIRED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				return isRequired != IS_REQUIRED_EDEFAULT;
-			case UMLXPackage.TX_PARAMETER_NODE__IS_UNIQUE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				return isUnique != IS_UNIQUE_EDEFAULT;
-			case UMLXPackage.TX_PARAMETER_NODE__REFERRED_ECLASSIFIER:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6:
 				return referredEClassifier != null;
-			case UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				return getOwningTxQueryNode() != null;
 		}
 		return super.eIsSet(featureID);
@@ -696,18 +733,18 @@
 	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
 		if (baseClass == UMLXNamedElement.class) {
 			switch (derivedFeatureID) {
-				case UMLXPackage.TX_PARAMETER_NODE__NAME: return UMLXPackage.UMLX_NAMED_ELEMENT__NAME;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0: return UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0;
 				default: return -1;
 			}
 		}
 		if (baseClass == UMLXTypedElement.class) {
 			switch (derivedFeatureID) {
-				case UMLXPackage.TX_PARAMETER_NODE__IS_MANY: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY;
-				case UMLXPackage.TX_PARAMETER_NODE__IS_NULL_FREE: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE;
-				case UMLXPackage.TX_PARAMETER_NODE__IS_ORDERED: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED;
-				case UMLXPackage.TX_PARAMETER_NODE__IS_REQUIRED: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED;
-				case UMLXPackage.TX_PARAMETER_NODE__IS_UNIQUE: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE;
-				case UMLXPackage.TX_PARAMETER_NODE__REFERRED_ECLASSIFIER: return UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5;
 				default: return -1;
 			}
 		}
@@ -723,18 +760,18 @@
 	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
 		if (baseClass == UMLXNamedElement.class) {
 			switch (baseFeatureID) {
-				case UMLXPackage.UMLX_NAMED_ELEMENT__NAME: return UMLXPackage.TX_PARAMETER_NODE__NAME;
+				case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 0;
 				default: return -1;
 			}
 		}
 		if (baseClass == UMLXTypedElement.class) {
 			switch (baseFeatureID) {
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY: return UMLXPackage.TX_PARAMETER_NODE__IS_MANY;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE: return UMLXPackage.TX_PARAMETER_NODE__IS_NULL_FREE;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED: return UMLXPackage.TX_PARAMETER_NODE__IS_ORDERED;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED: return UMLXPackage.TX_PARAMETER_NODE__IS_REQUIRED;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE: return UMLXPackage.TX_PARAMETER_NODE__IS_UNIQUE;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER: return UMLXPackage.TX_PARAMETER_NODE__REFERRED_ECLASSIFIER;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 1;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 2;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 3;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 4;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 5;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 6;
 				default: return -1;
 			}
 		}
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxPartNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxPartNodeImpl.java
index 7b3df7a..8083e27 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxPartNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxPartNodeImpl.java
@@ -10,6 +10,7 @@
  */
 package org.eclipse.qvtd.umlx.impl;
 
+import java.util.List;
 import java.util.Map;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
@@ -21,12 +22,13 @@
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.StandardLibrary;
 import org.eclipse.ocl.pivot.evaluation.Executor;
+import org.eclipse.ocl.pivot.ids.IdResolver;
 import org.eclipse.ocl.pivot.ids.TypeId;
 import org.eclipse.ocl.pivot.internal.library.executor.ExecutorSingleIterationManager;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.AbstractBinaryOperation;
-import org.eclipse.ocl.pivot.library.LibraryIteration;
+import org.eclipse.ocl.pivot.library.LibraryIteration.LibraryIterationExtension;
 import org.eclipse.ocl.pivot.library.collection.CollectionIncludesOperation;
 import org.eclipse.ocl.pivot.library.oclany.OclAnyOclAsSetOperation;
 import org.eclipse.ocl.pivot.library.oclany.OclAnyOclAsTypeOperation;
@@ -34,9 +36,11 @@
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
 import org.eclipse.ocl.pivot.oclstdlib.OCLstdlibTables;
-import org.eclipse.ocl.pivot.utilities.ClassUtil;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
+import org.eclipse.ocl.pivot.values.IntegerValue;
 import org.eclipse.ocl.pivot.values.InvalidValueException;
+import org.eclipse.ocl.pivot.values.OrderedSetValue;
 import org.eclipse.ocl.pivot.values.SetValue;
 import org.eclipse.qvtd.umlx.TxKeyNode;
 import org.eclipse.qvtd.umlx.TxPartNode;
@@ -61,6 +65,15 @@
  */
 public class TxPartNodeImpl extends TxNodeImpl implements TxPartNode {
 	/**
+	 * The number of structural features of the '<em>Tx Part Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int TX_PART_NODE_FEATURE_COUNT = TxNodeImpl.TX_NODE_FEATURE_COUNT + 3;
+
+	/**
 	 * The default value of the '{@link #isIsOpposite() <em>Is Opposite</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -116,7 +129,7 @@
 	 */
 	@Override
 	public TxKeyNode getOwningTxKeyNode() {
-		if (eContainerFeatureID() != UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE) return null;
+		if (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 0)) return null;
 		return (TxKeyNode)eInternalContainer();
 	}
 
@@ -126,7 +139,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningTxKeyNode(TxKeyNode newOwningTxKeyNode, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningTxKeyNode, UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningTxKeyNode, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0, msgs);
 		return msgs;
 	}
 
@@ -137,19 +150,19 @@
 	 */
 	@Override
 	public void setOwningTxKeyNode(TxKeyNode newOwningTxKeyNode) {
-		if (newOwningTxKeyNode != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE && newOwningTxKeyNode != null)) {
+		if (newOwningTxKeyNode != eInternalContainer() || (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 0) && newOwningTxKeyNode != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningTxKeyNode))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningTxKeyNode != null)
-				msgs = ((InternalEObject)newOwningTxKeyNode).eInverseAdd(this, UMLXPackage.TX_KEY_NODE__OWNED_TX_PART_NODES, TxKeyNode.class, msgs);
+				msgs = ((InternalEObject)newOwningTxKeyNode).eInverseAdd(this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0, TxKeyNode.class, msgs);
 			msgs = basicSetOwningTxKeyNode(newOwningTxKeyNode, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE, newOwningTxKeyNode, newOwningTxKeyNode));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0, newOwningTxKeyNode, newOwningTxKeyNode));
 	}
 
 	/**
@@ -172,7 +185,7 @@
 		boolean oldIsOpposite = isOpposite;
 		isOpposite = newIsOpposite;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PART_NODE__IS_OPPOSITE, oldIsOpposite, isOpposite));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1, oldIsOpposite, isOpposite));
 	}
 
 	/**
@@ -187,7 +200,7 @@
 			referredEStructuralFeature = (EStructuralFeature)eResolveProxy(oldReferredEStructuralFeature);
 			if (referredEStructuralFeature != oldReferredEStructuralFeature) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.TX_PART_NODE__REFERRED_ESTRUCTURAL_FEATURE, oldReferredEStructuralFeature, referredEStructuralFeature));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2, oldReferredEStructuralFeature, referredEStructuralFeature));
 			}
 		}
 		return referredEStructuralFeature;
@@ -212,7 +225,7 @@
 		EStructuralFeature oldReferredEStructuralFeature = referredEStructuralFeature;
 		referredEStructuralFeature = newReferredEStructuralFeature;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_PART_NODE__REFERRED_ESTRUCTURAL_FEATURE, oldReferredEStructuralFeature, referredEStructuralFeature));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2, oldReferredEStructuralFeature, referredEStructuralFeature));
 	}
 
 	/**
@@ -222,78 +235,85 @@
 	 */
 	@Override
 	public boolean validatePartIsPropertyOfKey(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv PartIsPropertyOfKey:
-		 *   let severity : Integer[1] = 'TxPartNode::PartIsPropertyOfKey'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let
-		 *         result : Boolean[1] = owningTxKeyNode.referredEClass.oclAsType(ecore::EClass)
-		 *         ->closure(eSuperTypes)
-		 *         ->includes(referredEStructuralFeature.eContainingClass)
-		 *       in
-		 *         'TxPartNode::PartIsPropertyOfKey'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull StandardLibrary standardLibrary = idResolver.getStandardLibrary();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxPartNode_c_c_PartIsPropertyOfKey);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_1;
-		if (le) {
-			symbol_1 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_result;
-			try {
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_0 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
-				@SuppressWarnings("null")
-				final /*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull TxKeyNode owningTxKeyNode = this.getOwningTxKeyNode();
-				@SuppressWarnings("null")
-				final /*@NonInvalid*/ org.eclipse.emf.ecore.@NonNull EClass referredEClass = owningTxKeyNode.getReferredEClass();
-				final /*@Thrown*/ org.eclipse.emf.ecore.@NonNull EClass oclAsType = ClassUtil.nonNullState((EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClass, TYP_ecore_c_c_EClass_0));
-				final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue oclAsSet = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, oclAsType);
-				final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_0 = executor.getStaticTypeOf(oclAsSet);
-				final LibraryIteration.@org.eclipse.jdt.annotation.NonNull LibraryIterationExtension IMPL_closure_0 = (LibraryIteration.LibraryIterationExtension)TYPE_closure_0.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
-				final @NonNull Object ACC_closure_0 = IMPL_closure_0.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
-				/**
-				 * Implementation of the iterator body.
-				 */
-				final @NonNull AbstractBinaryOperation BODY_closure_0 = new AbstractBinaryOperation() {
+		try {
+			/**
+			 *
+			 * inv PartIsPropertyOfKey:
+			 *   let severity : Integer[1] = 'TxPartNode::PartIsPropertyOfKey'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let
+			 *         result : Boolean[1] = owningTxKeyNode.referredEClass.oclAsType(ecore::EClass)
+			 *         ->closure(eSuperTypes)
+			 *         ->includes(referredEStructuralFeature.eContainingClass)
+			 *       in
+			 *         'TxPartNode::PartIsPropertyOfKey'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull StandardLibrary standardLibrary = idResolver.getStandardLibrary();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxPartNode_c_c_PartIsPropertyOfKey);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_1;
+			if (le) {
+				symbol_1 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @NonNull Object CAUGHT_result;
+				try {
+					final /*@NonInvalid*/ org.eclipse.ocl.pivot.@NonNull Class TYP_ecore_c_c_EClass_0 = idResolver.getClass(UMLXTables.CLSSid_EClass, null);
+					@SuppressWarnings("null")
+					final /*@NonInvalid*/ @NonNull TxKeyNode owningTxKeyNode = this.getOwningTxKeyNode();
+					@SuppressWarnings("null")
+					final /*@NonInvalid*/ @NonNull EClass referredEClass = owningTxKeyNode.getReferredEClass();
+					@SuppressWarnings("null")
+					final /*@Thrown*/ @NonNull EClass oclAsType = (@NonNull EClass)OclAnyOclAsTypeOperation.INSTANCE.evaluate(executor, referredEClass, TYP_ecore_c_c_EClass_0);
+					final /*@Thrown*/ @NonNull SetValue oclAsSet = OclAnyOclAsSetOperation.INSTANCE.evaluate(executor, UMLXTables.SET_CLSSid_EClass, oclAsType);
+					final org.eclipse.ocl.pivot.@NonNull Class TYPE_closure_0 = executor.getStaticTypeOfValue(null, oclAsSet);
+					final @NonNull LibraryIterationExtension IMPL_closure_0 = (LibraryIterationExtension)TYPE_closure_0.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__closure);
+					final @NonNull Object ACC_closure_0 = IMPL_closure_0.createAccumulatorValue(executor, UMLXTables.SET_CLSSid_EClass, UMLXTables.ORD_CLSSid_EClass);
 					/**
-					 * eSuperTypes
+					 * Implementation of the iterator body.
 					 */
-					@Override
-					public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet, final /*@NonInvalid*/ java.lang.@Nullable Object _1) {
-						final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClass symbol_0 = (EClass)_1;
-						if (symbol_0 == null) {
-							throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
+					final @NonNull AbstractBinaryOperation BODY_closure_0 = new AbstractBinaryOperation() {
+						/**
+						 * eSuperTypes
+						 */
+						@Override
+						public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object oclAsSet, final /*@NonInvalid*/ @Nullable Object _1) {
+							final /*@NonInvalid*/ @Nullable EClass symbol_0 = (EClass)_1;
+							if (symbol_0 == null) {
+								throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/emf/2002/Ecore\'::EClass::eSuperTypes\'");
+							}
+							@SuppressWarnings("null")
+							final /*@Thrown*/ @NonNull List<EClass> eSuperTypes = symbol_0.getESuperTypes();
+							final /*@Thrown*/ @NonNull OrderedSetValue BOXED_eSuperTypes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes);
+							return BOXED_eSuperTypes;
 						}
-						@SuppressWarnings("null")
-						final /*@Thrown*/ java.util.@NonNull List<EClass> eSuperTypes = symbol_0.getESuperTypes();
-						final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_eSuperTypes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_EClass, eSuperTypes);
-						return BOXED_eSuperTypes;
-					}
-				};
-				final @NonNull  ExecutorSingleIterationManager MGR_closure_0 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_0, oclAsSet, ACC_closure_0);
-				final /*@Thrown*/ org.eclipse.ocl.pivot.values.@NonNull SetValue closure = ClassUtil.nonNullState((SetValue)IMPL_closure_0.evaluateIteration(MGR_closure_0));
-				@SuppressWarnings("null")
-				final /*@NonInvalid*/ org.eclipse.emf.ecore.@NonNull EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
-				final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClass eContainingClass = referredEStructuralFeature.getEContainingClass();
-				final /*@Thrown*/ boolean result = CollectionIncludesOperation.INSTANCE.evaluate(closure, eContainingClass).booleanValue();
-				CAUGHT_result = result;
+					};
+					final @NonNull ExecutorSingleIterationManager MGR_closure_0 = new ExecutorSingleIterationManager(executor, UMLXTables.SET_CLSSid_EClass, BODY_closure_0, oclAsSet, ACC_closure_0);
+					@SuppressWarnings("null")
+					final /*@Thrown*/ @NonNull SetValue closure = (@NonNull SetValue)IMPL_closure_0.evaluateIteration(MGR_closure_0);
+					@SuppressWarnings("null")
+					final /*@NonInvalid*/ @NonNull EStructuralFeature referredEStructuralFeature = this.getReferredEStructuralFeature();
+					final /*@NonInvalid*/ @Nullable EClass eContainingClass = referredEStructuralFeature.getEContainingClass();
+					final /*@Thrown*/ boolean result = CollectionIncludesOperation.INSTANCE.evaluate(closure, eContainingClass).booleanValue();
+					CAUGHT_result = result;
+				}
+				catch (Exception e) {
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
+				}
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxPartNode_c_c_PartIsPropertyOfKey, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_1 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxPartNode_c_c_PartIsPropertyOfKey, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_1 = logDiagnostic;
+			return Boolean.TRUE == symbol_1;
 		}
-		return Boolean.TRUE == symbol_1;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxPartNode::PartIsPropertyOfKey", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -304,7 +324,7 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningTxKeyNode((TxKeyNode)otherEnd, msgs);
@@ -320,7 +340,7 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return basicSetOwningTxKeyNode(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -334,8 +354,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.TX_KEY_NODE__OWNED_TX_PART_NODES, TxKeyNode.class, msgs);
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
+				return eInternalContainer().eInverseRemove(this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0, TxKeyNode.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -348,11 +368,11 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return getOwningTxKeyNode();
-			case UMLXPackage.TX_PART_NODE__IS_OPPOSITE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return isIsOpposite();
-			case UMLXPackage.TX_PART_NODE__REFERRED_ESTRUCTURAL_FEATURE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				if (resolve) return getReferredEStructuralFeature();
 				return basicGetReferredEStructuralFeature();
 		}
@@ -367,13 +387,13 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				setOwningTxKeyNode((TxKeyNode)newValue);
 				return;
-			case UMLXPackage.TX_PART_NODE__IS_OPPOSITE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setIsOpposite((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_PART_NODE__REFERRED_ESTRUCTURAL_FEATURE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setReferredEStructuralFeature((EStructuralFeature)newValue);
 				return;
 		}
@@ -388,13 +408,13 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				setOwningTxKeyNode((TxKeyNode)null);
 				return;
-			case UMLXPackage.TX_PART_NODE__IS_OPPOSITE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setIsOpposite(IS_OPPOSITE_EDEFAULT);
 				return;
-			case UMLXPackage.TX_PART_NODE__REFERRED_ESTRUCTURAL_FEATURE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setReferredEStructuralFeature((EStructuralFeature)null);
 				return;
 		}
@@ -409,11 +429,11 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_PART_NODE__OWNING_TX_KEY_NODE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return getOwningTxKeyNode() != null;
-			case UMLXPackage.TX_PART_NODE__IS_OPPOSITE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return isOpposite != IS_OPPOSITE_EDEFAULT;
-			case UMLXPackage.TX_PART_NODE__REFERRED_ESTRUCTURAL_FEATURE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				return referredEStructuralFeature != null;
 		}
 		return super.eIsSet(featureID);
@@ -435,7 +455,13 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (isOpposite: ");
+		result.append(isOpposite);
+		result.append(')');
+		return result.toString();
 	}
 
 } //TxPartNodeImpl
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxQueryNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxQueryNodeImpl.java
index 7ccdb94..fef8518 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxQueryNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxQueryNodeImpl.java
@@ -12,6 +12,7 @@
 
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 
 import org.eclipse.emf.common.notify.Notification;
@@ -34,13 +35,17 @@
 import org.eclipse.jdt.annotation.NonNull;
 
 import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.evaluation.Executor;
+import org.eclipse.ocl.pivot.ids.IdResolver;
 import org.eclipse.ocl.pivot.ids.TypeId;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.oclany.OclComparableLessThanEqualOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
-import org.eclipse.ocl.pivot.values.SetValue;
+import org.eclipse.ocl.pivot.values.IntegerValue;
+import org.eclipse.ocl.pivot.values.OrderedSetValue;
+import org.eclipse.ocl.pivot.values.SetValue.Accumulator;
 import org.eclipse.qvtd.umlx.TxDiagram;
 import org.eclipse.qvtd.umlx.TxParameterNode;
 import org.eclipse.qvtd.umlx.TxQueryNode;
@@ -75,6 +80,15 @@
  */
 public class TxQueryNodeImpl extends TxNodeImpl implements TxQueryNode {
 	/**
+	 * The number of structural features of the '<em>Tx Query Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int TX_QUERY_NODE_FEATURE_COUNT = TxNodeImpl.TX_NODE_FEATURE_COUNT + 10;
+
+	/**
 	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -263,7 +277,7 @@
 		String oldName = name;
 		name = newName;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_QUERY_NODE__NAME, oldName, name));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0, oldName, name));
 	}
 
 	/**
@@ -286,7 +300,7 @@
 		boolean oldIsMany = isMany;
 		isMany = newIsMany;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_QUERY_NODE__IS_MANY, oldIsMany, isMany));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1, oldIsMany, isMany));
 	}
 
 	/**
@@ -309,7 +323,7 @@
 		boolean oldIsNullFree = isNullFree;
 		isNullFree = newIsNullFree;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_QUERY_NODE__IS_NULL_FREE, oldIsNullFree, isNullFree));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2, oldIsNullFree, isNullFree));
 	}
 
 	/**
@@ -332,7 +346,7 @@
 		boolean oldIsOrdered = isOrdered;
 		isOrdered = newIsOrdered;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_QUERY_NODE__IS_ORDERED, oldIsOrdered, isOrdered));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 3, oldIsOrdered, isOrdered));
 	}
 
 	/**
@@ -355,7 +369,7 @@
 		boolean oldIsRequired = isRequired;
 		isRequired = newIsRequired;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_QUERY_NODE__IS_REQUIRED, oldIsRequired, isRequired));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 4, oldIsRequired, isRequired));
 	}
 
 	/**
@@ -378,7 +392,7 @@
 		boolean oldIsUnique = isUnique;
 		isUnique = newIsUnique;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_QUERY_NODE__IS_UNIQUE, oldIsUnique, isUnique));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 5, oldIsUnique, isUnique));
 	}
 
 	/**
@@ -393,7 +407,7 @@
 			referredEClassifier = (EClassifier)eResolveProxy(oldReferredEClassifier);
 			if (referredEClassifier != oldReferredEClassifier) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.TX_QUERY_NODE__REFERRED_ECLASSIFIER, oldReferredEClassifier, referredEClassifier));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, TxNodeImpl.TX_NODE_FEATURE_COUNT + 6, oldReferredEClassifier, referredEClassifier));
 			}
 		}
 		return referredEClassifier;
@@ -418,7 +432,7 @@
 		EClassifier oldReferredEClassifier = referredEClassifier;
 		referredEClassifier = newReferredEClassifier;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_QUERY_NODE__REFERRED_ECLASSIFIER, oldReferredEClassifier, referredEClassifier));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 6, oldReferredEClassifier, referredEClassifier));
 	}
 
 	/**
@@ -429,7 +443,7 @@
 	@Override
 	public EList<String> getInitExpressionLines() {
 		if (initExpressionLines == null) {
-			initExpressionLines = new EDataTypeUniqueEList<String>(String.class, this, UMLXPackage.TX_QUERY_NODE__INIT_EXPRESSION_LINES);
+			initExpressionLines = new EDataTypeUniqueEList<String>(String.class, this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 7);
 		}
 		return initExpressionLines;
 	}
@@ -442,7 +456,7 @@
 	@Override
 	public EList<TxParameterNode> getOwnedTxParameterNodes() {
 		if (ownedTxParameterNodes == null) {
-			ownedTxParameterNodes = new EObjectContainmentWithInverseEList<TxParameterNode>(TxParameterNode.class, this, UMLXPackage.TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES, UMLXPackage.TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE);
+			ownedTxParameterNodes = new EObjectContainmentWithInverseEList<TxParameterNode>(TxParameterNode.class, this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 8, TxNodeImpl.TX_NODE_FEATURE_COUNT + 7);
 		}
 		return ownedTxParameterNodes;
 	}
@@ -454,7 +468,7 @@
 	 */
 	@Override
 	public TxDiagram getOwningTxDiagram() {
-		if (eContainerFeatureID() != UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM) return null;
+		if (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 9)) return null;
 		return (TxDiagram)eInternalContainer();
 	}
 
@@ -464,7 +478,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningTxDiagram(TxDiagram newOwningTxDiagram, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, TxNodeImpl.TX_NODE_FEATURE_COUNT + 9, msgs);
 		return msgs;
 	}
 
@@ -475,19 +489,19 @@
 	 */
 	@Override
 	public void setOwningTxDiagram(TxDiagram newOwningTxDiagram) {
-		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM && newOwningTxDiagram != null)) {
+		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 9) && newOwningTxDiagram != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningTxDiagram))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningTxDiagram != null)
-				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXPackage.TX_DIAGRAM__OWNED_TX_QUERY_NODES, TxDiagram.class, msgs);
+				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3, TxDiagram.class, msgs);
 			msgs = basicSetOwningTxDiagram(newOwningTxDiagram, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM, newOwningTxDiagram, newOwningTxDiagram));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 9, newOwningTxDiagram, newOwningTxDiagram));
 	}
 
 	/**
@@ -497,33 +511,38 @@
 	 */
 	@Override
 	public boolean validateNameIsRequired(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv NameIsRequired:
-		 *   let severity : Integer[1] = 'TxQueryNode::NameIsRequired'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = name <> null
-		 *       in
-		 *         'TxQueryNode::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxQueryNode_c_c_NameIsRequired);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv NameIsRequired:
+			 *   let severity : Integer[1] = 'TxQueryNode::NameIsRequired'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = name <> null
+			 *       in
+			 *         'TxQueryNode::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxQueryNode_c_c_NameIsRequired);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				final /*@NonInvalid*/ @Nullable String name = this.getName();
+				final /*@NonInvalid*/ boolean result = name != null;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxQueryNode_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			final /*@NonInvalid*/ java.lang.@Nullable String name = this.getName();
-			final /*@NonInvalid*/ boolean result = name != null;
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxQueryNode_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxQueryNode::NameIsRequired", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -533,33 +552,38 @@
 	 */
 	@Override
 	public boolean validateTypeIsRequired(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv TypeIsRequired:
-		 *   let severity : Integer[1] = 'TxQueryNode::TypeIsRequired'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = referredEClassifier <> null
-		 *       in
-		 *         'TxQueryNode::TypeIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxQueryNode_c_c_TypeIsRequired);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv TypeIsRequired:
+			 *   let severity : Integer[1] = 'TxQueryNode::TypeIsRequired'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = referredEClassifier <> null
+			 *       in
+			 *         'TxQueryNode::TypeIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxQueryNode_c_c_TypeIsRequired);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				final /*@NonInvalid*/ @Nullable EClassifier referredEClassifier = this.getReferredEClassifier();
+				final /*@NonInvalid*/ boolean result = referredEClassifier != null;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxQueryNode_c_c_TypeIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			final /*@NonInvalid*/ org.eclipse.emf.ecore.@Nullable EClassifier referredEClassifier = this.getReferredEClassifier();
-			final /*@NonInvalid*/ boolean result = referredEClassifier != null;
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxQueryNode_c_c_TypeIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxQueryNode::TypeIsRequired", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -569,65 +593,70 @@
 	 */
 	@Override
 	public boolean validateParametersAreUnique(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv ParametersAreUnique:
-		 *   let severity : Integer[1] = 'TxQueryNode::ParametersAreUnique'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = ownedTxParameterNodes->isUnique(name)
-		 *       in
-		 *         'TxQueryNode::ParametersAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxQueryNode_c_c_ParametersAreUnique);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_result;
-			try {
-				@SuppressWarnings("null")
-				final /*@NonInvalid*/ java.util.@NonNull List<TxParameterNode> ownedTxParameterNodes = this.getOwnedTxParameterNodes();
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_ownedTxParameterNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxParameterNode, ownedTxParameterNodes);
-				/*@Thrown*/ SetValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxParameterNode);
-				@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedTxParameterNodes.iterator();
-				/*@Thrown*/ boolean result;
-				while (true) {
-					if (!ITERATOR__1.hasNext()) {
-						result = ValueUtil.TRUE_VALUE;
-						break;
-					}
+		try {
+			/**
+			 *
+			 * inv ParametersAreUnique:
+			 *   let severity : Integer[1] = 'TxQueryNode::ParametersAreUnique'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = ownedTxParameterNodes->isUnique(name)
+			 *       in
+			 *         'TxQueryNode::ParametersAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxQueryNode_c_c_ParametersAreUnique);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				/*@Caught*/ @NonNull Object CAUGHT_result;
+				try {
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull TxParameterNode _1 = (TxParameterNode)ITERATOR__1.next();
-					/**
-					 * name
-					 */
-					final /*@NonInvalid*/ java.lang.@Nullable String name = _1.getName();
-					//
-					if (accumulator.includes(name) == ValueUtil.TRUE_VALUE) {
-						result = ValueUtil.FALSE_VALUE;			// Abort after second find
-						break;
+					final /*@NonInvalid*/ @NonNull List<TxParameterNode> ownedTxParameterNodes = this.getOwnedTxParameterNodes();
+					final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_ownedTxParameterNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxParameterNode, ownedTxParameterNodes);
+					/*@Thrown*/ @NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxParameterNode);
+					@NonNull Iterator<Object> ITERATOR__1 = BOXED_ownedTxParameterNodes.iterator();
+					/*@Thrown*/ boolean result;
+					while (true) {
+						if (!ITERATOR__1.hasNext()) {
+							result = ValueUtil.TRUE_VALUE;
+							break;
+						}
+						@SuppressWarnings("null")
+						/*@NonInvalid*/ @NonNull TxParameterNode _1 = (@NonNull TxParameterNode)ITERATOR__1.next();
+						/**
+						 * name
+						 */
+						final /*@NonInvalid*/ @Nullable String name = _1.getName();
+						//
+						if (accumulator.includes(name) == ValueUtil.TRUE_VALUE) {
+							result = ValueUtil.FALSE_VALUE;			// Abort after second find
+							break;
+						}
+						else {
+							accumulator.add(name);
+						}
 					}
-					else {
-						accumulator.add(name);
-					}
+					CAUGHT_result = result;
 				}
-				CAUGHT_result = result;
+				catch (Exception e) {
+					CAUGHT_result = ValueUtil.createInvalidValue(e);
+				}
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxQueryNode_c_c_ParametersAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxQueryNode_c_c_ParametersAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxQueryNode::ParametersAreUnique", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -637,7 +666,25 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: ");
+		result.append(name);
+		result.append(", isMany: ");
+		result.append(isMany);
+		result.append(", isNullFree: ");
+		result.append(isNullFree);
+		result.append(", isOrdered: ");
+		result.append(isOrdered);
+		result.append(", isRequired: ");
+		result.append(isRequired);
+		result.append(", isUnique: ");
+		result.append(isUnique);
+		result.append(", initExpressionLines: ");
+		result.append(initExpressionLines);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -649,9 +696,9 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 8:
 				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOwnedTxParameterNodes()).basicAdd(otherEnd, msgs);
-			case UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 9:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningTxDiagram((TxDiagram)otherEnd, msgs);
@@ -667,9 +714,9 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 8:
 				return ((InternalEList<?>)getOwnedTxParameterNodes()).basicRemove(otherEnd, msgs);
-			case UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 9:
 				return basicSetOwningTxDiagram(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -683,8 +730,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.TX_DIAGRAM__OWNED_TX_QUERY_NODES, TxDiagram.class, msgs);
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 9:
+				return eInternalContainer().eInverseRemove(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3, TxDiagram.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -697,26 +744,26 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.TX_QUERY_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return getName();
-			case UMLXPackage.TX_QUERY_NODE__IS_MANY:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return isIsMany();
-			case UMLXPackage.TX_QUERY_NODE__IS_NULL_FREE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				return isIsNullFree();
-			case UMLXPackage.TX_QUERY_NODE__IS_ORDERED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				return isIsOrdered();
-			case UMLXPackage.TX_QUERY_NODE__IS_REQUIRED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				return isIsRequired();
-			case UMLXPackage.TX_QUERY_NODE__IS_UNIQUE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				return isIsUnique();
-			case UMLXPackage.TX_QUERY_NODE__REFERRED_ECLASSIFIER:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6:
 				if (resolve) return getReferredEClassifier();
 				return basicGetReferredEClassifier();
-			case UMLXPackage.TX_QUERY_NODE__INIT_EXPRESSION_LINES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				return getInitExpressionLines();
-			case UMLXPackage.TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 8:
 				return getOwnedTxParameterNodes();
-			case UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 9:
 				return getOwningTxDiagram();
 		}
 		return super.eGet(featureID, resolve, coreType);
@@ -731,36 +778,36 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.TX_QUERY_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				setName((String)newValue);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_MANY:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setIsMany((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_NULL_FREE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setIsNullFree((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_ORDERED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				setIsOrdered((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_REQUIRED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				setIsRequired((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_UNIQUE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				setIsUnique((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__REFERRED_ECLASSIFIER:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6:
 				setReferredEClassifier((EClassifier)newValue);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__INIT_EXPRESSION_LINES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				getInitExpressionLines().clear();
 				getInitExpressionLines().addAll((Collection<? extends String>)newValue);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 8:
 				getOwnedTxParameterNodes().clear();
 				getOwnedTxParameterNodes().addAll((Collection<? extends TxParameterNode>)newValue);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 9:
 				setOwningTxDiagram((TxDiagram)newValue);
 				return;
 		}
@@ -775,34 +822,34 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_QUERY_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				setName(NAME_EDEFAULT);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_MANY:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setIsMany(IS_MANY_EDEFAULT);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_NULL_FREE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				setIsNullFree(IS_NULL_FREE_EDEFAULT);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_ORDERED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				setIsOrdered(IS_ORDERED_EDEFAULT);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_REQUIRED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				setIsRequired(IS_REQUIRED_EDEFAULT);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__IS_UNIQUE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				setIsUnique(IS_UNIQUE_EDEFAULT);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__REFERRED_ECLASSIFIER:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6:
 				setReferredEClassifier((EClassifier)null);
 				return;
-			case UMLXPackage.TX_QUERY_NODE__INIT_EXPRESSION_LINES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				getInitExpressionLines().clear();
 				return;
-			case UMLXPackage.TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 8:
 				getOwnedTxParameterNodes().clear();
 				return;
-			case UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 9:
 				setOwningTxDiagram((TxDiagram)null);
 				return;
 		}
@@ -817,25 +864,25 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_QUERY_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case UMLXPackage.TX_QUERY_NODE__IS_MANY:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return isMany != IS_MANY_EDEFAULT;
-			case UMLXPackage.TX_QUERY_NODE__IS_NULL_FREE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				return isNullFree != IS_NULL_FREE_EDEFAULT;
-			case UMLXPackage.TX_QUERY_NODE__IS_ORDERED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				return isOrdered != IS_ORDERED_EDEFAULT;
-			case UMLXPackage.TX_QUERY_NODE__IS_REQUIRED:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				return isRequired != IS_REQUIRED_EDEFAULT;
-			case UMLXPackage.TX_QUERY_NODE__IS_UNIQUE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				return isUnique != IS_UNIQUE_EDEFAULT;
-			case UMLXPackage.TX_QUERY_NODE__REFERRED_ECLASSIFIER:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6:
 				return referredEClassifier != null;
-			case UMLXPackage.TX_QUERY_NODE__INIT_EXPRESSION_LINES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 7:
 				return initExpressionLines != null && !initExpressionLines.isEmpty();
-			case UMLXPackage.TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 8:
 				return ownedTxParameterNodes != null && !ownedTxParameterNodes.isEmpty();
-			case UMLXPackage.TX_QUERY_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 9:
 				return getOwningTxDiagram() != null;
 		}
 		return super.eIsSet(featureID);
@@ -850,18 +897,18 @@
 	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
 		if (baseClass == UMLXNamedElement.class) {
 			switch (derivedFeatureID) {
-				case UMLXPackage.TX_QUERY_NODE__NAME: return UMLXPackage.UMLX_NAMED_ELEMENT__NAME;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0: return UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0;
 				default: return -1;
 			}
 		}
 		if (baseClass == UMLXTypedElement.class) {
 			switch (derivedFeatureID) {
-				case UMLXPackage.TX_QUERY_NODE__IS_MANY: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY;
-				case UMLXPackage.TX_QUERY_NODE__IS_NULL_FREE: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE;
-				case UMLXPackage.TX_QUERY_NODE__IS_ORDERED: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED;
-				case UMLXPackage.TX_QUERY_NODE__IS_REQUIRED: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED;
-				case UMLXPackage.TX_QUERY_NODE__IS_UNIQUE: return UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE;
-				case UMLXPackage.TX_QUERY_NODE__REFERRED_ECLASSIFIER: return UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 6: return UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5;
 				default: return -1;
 			}
 		}
@@ -877,18 +924,18 @@
 	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
 		if (baseClass == UMLXNamedElement.class) {
 			switch (baseFeatureID) {
-				case UMLXPackage.UMLX_NAMED_ELEMENT__NAME: return UMLXPackage.TX_QUERY_NODE__NAME;
+				case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 0;
 				default: return -1;
 			}
 		}
 		if (baseClass == UMLXTypedElement.class) {
 			switch (baseFeatureID) {
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY: return UMLXPackage.TX_QUERY_NODE__IS_MANY;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE: return UMLXPackage.TX_QUERY_NODE__IS_NULL_FREE;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED: return UMLXPackage.TX_QUERY_NODE__IS_ORDERED;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED: return UMLXPackage.TX_QUERY_NODE__IS_REQUIRED;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE: return UMLXPackage.TX_QUERY_NODE__IS_UNIQUE;
-				case UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER: return UMLXPackage.TX_QUERY_NODE__REFERRED_ECLASSIFIER;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 1;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 2;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 3;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 4;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 5;
+				case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 6;
 				default: return -1;
 			}
 		}
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxTypedModelNodeImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxTypedModelNodeImpl.java
index aa682b1..94ec7ab 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxTypedModelNodeImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/TxTypedModelNodeImpl.java
@@ -13,25 +13,31 @@
 import java.util.Collection;
 
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.util.EObjectResolvingEList;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.evaluation.Executor;
+import org.eclipse.ocl.pivot.ids.IdResolver;
 import org.eclipse.ocl.pivot.ids.TypeId;
-import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal;
 import org.eclipse.ocl.pivot.library.oclany.OclComparableLessThanEqualOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringGetSeverityOperation;
 import org.eclipse.ocl.pivot.library.string.CGStringLogDiagnosticOperation;
+import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
-import org.eclipse.ocl.pivot.values.SetValue;
+import org.eclipse.ocl.pivot.values.IntegerValue;
+import org.eclipse.ocl.pivot.values.OrderedSetValue;
+import org.eclipse.ocl.pivot.values.SetValue.Accumulator;
 import org.eclipse.qvtd.umlx.TxDiagram;
 import org.eclipse.qvtd.umlx.TxPackageNode;
 import org.eclipse.qvtd.umlx.TxTypedModelNode;
@@ -60,6 +66,15 @@
  */
 public class TxTypedModelNodeImpl extends TxNodeImpl implements TxTypedModelNode {
 	/**
+	 * The number of structural features of the '<em>Tx Typed Model Node</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int TX_TYPED_MODEL_NODE_FEATURE_COUNT = TxNodeImpl.TX_NODE_FEATURE_COUNT + 6;
+
+	/**
 	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -178,7 +193,7 @@
 		String oldName = name;
 		name = newName;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_TYPED_MODEL_NODE__NAME, oldName, name));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0, oldName, name));
 	}
 
 	/**
@@ -201,7 +216,7 @@
 		boolean oldCheck = check;
 		check = newCheck;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_TYPED_MODEL_NODE__CHECK, oldCheck, check));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1, oldCheck, check));
 	}
 
 	/**
@@ -212,7 +227,7 @@
 	@Override
 	public EList<TxTypedModelNode> getDependsOns() {
 		if (dependsOns == null) {
-			dependsOns = new EObjectResolvingEList<TxTypedModelNode>(TxTypedModelNode.class, this, UMLXPackage.TX_TYPED_MODEL_NODE__DEPENDS_ONS);
+			dependsOns = new EObjectResolvingEList<TxTypedModelNode>(TxTypedModelNode.class, this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2);
 		}
 		return dependsOns;
 	}
@@ -237,7 +252,7 @@
 		boolean oldEnforce = enforce;
 		enforce = newEnforce;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_TYPED_MODEL_NODE__ENFORCE, oldEnforce, enforce));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 3, oldEnforce, enforce));
 	}
 
 	/**
@@ -247,7 +262,7 @@
 	 */
 	@Override
 	public TxDiagram getOwningTxDiagram() {
-		if (eContainerFeatureID() != UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM) return null;
+		if (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 4)) return null;
 		return (TxDiagram)eInternalContainer();
 	}
 
@@ -257,7 +272,7 @@
 	 * @generated
 	 */
 	public NotificationChain basicSetOwningTxDiagram(TxDiagram newOwningTxDiagram, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newOwningTxDiagram, TxNodeImpl.TX_NODE_FEATURE_COUNT + 4, msgs);
 		return msgs;
 	}
 
@@ -268,19 +283,19 @@
 	 */
 	@Override
 	public void setOwningTxDiagram(TxDiagram newOwningTxDiagram) {
-		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM && newOwningTxDiagram != null)) {
+		if (newOwningTxDiagram != eInternalContainer() || (eContainerFeatureID() != (TxNodeImpl.TX_NODE_FEATURE_COUNT + 4) && newOwningTxDiagram != null)) {
 			if (EcoreUtil.isAncestor(this, newOwningTxDiagram))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newOwningTxDiagram != null)
-				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXPackage.TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES, TxDiagram.class, msgs);
+				msgs = ((InternalEObject)newOwningTxDiagram).eInverseAdd(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4, TxDiagram.class, msgs);
 			msgs = basicSetOwningTxDiagram(newOwningTxDiagram, msgs);
 			if (msgs != null) msgs.dispatch();
 		}
 		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM, newOwningTxDiagram, newOwningTxDiagram));
+			eNotify(new ENotificationImpl(this, Notification.SET, TxNodeImpl.TX_NODE_FEATURE_COUNT + 4, newOwningTxDiagram, newOwningTxDiagram));
 	}
 
 	/**
@@ -291,7 +306,7 @@
 	@Override
 	public EList<TxPackageNode> getUsedTxPackageNodes() {
 		if (usedTxPackageNodes == null) {
-			usedTxPackageNodes = new EObjectResolvingEList<TxPackageNode>(TxPackageNode.class, this, UMLXPackage.TX_TYPED_MODEL_NODE__USED_TX_PACKAGE_NODES);
+			usedTxPackageNodes = new EObjectResolvingEList<TxPackageNode>(TxPackageNode.class, this, TxNodeImpl.TX_NODE_FEATURE_COUNT + 5);
 		}
 		return usedTxPackageNodes;
 	}
@@ -303,50 +318,49 @@
 	 */
 	@Override
 	public boolean validateTxPackageNodePackagesAreUnique(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv TxPackageNodePackagesAreUnique:
-		 *   let
-		 *     severity : Integer[1] = 'TxTypedModelNode::TxPackageNodePackagesAreUnique'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let
-		 *         result : Boolean[1] = usedTxPackageNodes->isUnique(referredEPackage)
-		 *       in
-		 *         'TxTypedModelNode::TxPackageNodePackagesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@NonNull IdResolver idResolver = executor.getIdResolver();
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxTypedModelNode_c_c_TxPackageNodePackagesAreUnique);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
-		}
-		else {
-			/*@Caught*/ @NonNull Object CAUGHT_result;
-			try {
+		try {
+			/**
+			 *
+			 * inv TxPackageNodePackagesAreUnique:
+			 *   let
+			 *     severity : Integer[1] = 'TxTypedModelNode::TxPackageNodePackagesAreUnique'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let
+			 *         result : Boolean[1] = usedTxPackageNodes->isUnique(referredEPackage)
+			 *       in
+			 *         'TxTypedModelNode::TxPackageNodePackagesAreUnique'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IdResolver idResolver = executor.getIdResolver();
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxTypedModelNode_c_c_TxPackageNodePackagesAreUnique);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
 				@SuppressWarnings("null")
-				final /*@NonInvalid*/ java.util.@NonNull List<TxPackageNode> usedTxPackageNodes = this.getUsedTxPackageNodes();
-				final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull OrderedSetValue BOXED_usedTxPackageNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxPackageNode, usedTxPackageNodes);
-				/*@Thrown*/ SetValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxPackageNode);
+				final /*@NonInvalid*/ @NonNull List<TxPackageNode> usedTxPackageNodes = this.getUsedTxPackageNodes();
+				final /*@NonInvalid*/ @NonNull OrderedSetValue BOXED_usedTxPackageNodes = idResolver.createOrderedSetOfAll(UMLXTables.ORD_CLSSid_TxPackageNode, usedTxPackageNodes);
+				/*@Thrown*/ @NonNull Accumulator accumulator = ValueUtil.createSetAccumulatorValue(UMLXTables.ORD_CLSSid_TxPackageNode);
 				@NonNull Iterator<Object> ITERATOR__1 = BOXED_usedTxPackageNodes.iterator();
-				/*@Thrown*/ boolean result;
+				/*@NonInvalid*/ boolean result;
 				while (true) {
 					if (!ITERATOR__1.hasNext()) {
 						result = ValueUtil.TRUE_VALUE;
 						break;
 					}
 					@SuppressWarnings("null")
-					/*@NonInvalid*/ org.eclipse.qvtd.umlx.@NonNull TxPackageNode _1 = (TxPackageNode)ITERATOR__1.next();
+					/*@NonInvalid*/ @NonNull TxPackageNode _1 = (@NonNull TxPackageNode)ITERATOR__1.next();
 					/**
 					 * referredEPackage
 					 */
 					@SuppressWarnings("null")
-					final /*@NonInvalid*/ org.eclipse.emf.ecore.@NonNull EPackage referredEPackage = _1.getReferredEPackage();
+					final /*@NonInvalid*/ @NonNull EPackage referredEPackage = _1.getReferredEPackage();
 					//
 					if (accumulator.includes(referredEPackage) == ValueUtil.TRUE_VALUE) {
 						result = ValueUtil.FALSE_VALUE;			// Abort after second find
@@ -356,15 +370,14 @@
 						accumulator.add(referredEPackage);
 					}
 				}
-				CAUGHT_result = result;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxTypedModelNode_c_c_TxPackageNodePackagesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
 			}
-			catch (Exception e) {
-				CAUGHT_result = ValueUtil.createInvalidValue(e);
-			}
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxTypedModelNode_c_c_TxPackageNodePackagesAreUnique, this, (Object)null, diagnostics, context, (Object)null, severity_0, CAUGHT_result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+			return Boolean.TRUE == symbol_0;
 		}
-		return Boolean.TRUE == symbol_0;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxTypedModelNode::TxPackageNodePackagesAreUnique", this, diagnostics, context, e);
+		}
 	}
 
 	/**
@@ -374,33 +387,38 @@
 	 */
 	@Override
 	public boolean validateNameIsRequired(final DiagnosticChain diagnostics, final Map<Object, Object> context) {
-		/**
-		 *
-		 * inv NameIsRequired:
-		 *   let severity : Integer[1] = 'TxTypedModelNode::NameIsRequired'.getSeverity()
-		 *   in
-		 *     if severity <= 0
-		 *     then true
-		 *     else
-		 *       let result : Boolean[1] = name <> null
-		 *       in
-		 *         'TxTypedModelNode::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
-		 *     endif
-		 */
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.evaluation.@NonNull Executor executor = PivotUtilInternal.getExecutor(this);
-		final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxTypedModelNode_c_c_NameIsRequired);
-		final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
-		/*@NonInvalid*/ boolean symbol_0;
-		if (le) {
-			symbol_0 = ValueUtil.TRUE_VALUE;
+		try {
+			/**
+			 *
+			 * inv NameIsRequired:
+			 *   let severity : Integer[1] = 'TxTypedModelNode::NameIsRequired'.getSeverity()
+			 *   in
+			 *     if severity <= 0
+			 *     then true
+			 *     else
+			 *       let result : Boolean[1] = name <> null
+			 *       in
+			 *         'TxTypedModelNode::NameIsRequired'.logDiagnostic(self, null, diagnostics, context, null, severity, result, 0)
+			 *     endif
+			 */
+			final /*@NonInvalid*/ @NonNull Executor executor = PivotUtil.getExecutor(this, context);
+			final /*@NonInvalid*/ @NonNull IntegerValue severity_0 = CGStringGetSeverityOperation.INSTANCE.evaluate(executor, UMLXTables.STR_TxTypedModelNode_c_c_NameIsRequired);
+			final /*@NonInvalid*/ boolean le = OclComparableLessThanEqualOperation.INSTANCE.evaluate(executor, severity_0, UMLXTables.INT_0).booleanValue();
+			/*@NonInvalid*/ boolean symbol_0;
+			if (le) {
+				symbol_0 = ValueUtil.TRUE_VALUE;
+			}
+			else {
+				final /*@NonInvalid*/ @Nullable String name = this.getName();
+				final /*@NonInvalid*/ boolean result = name != null;
+				final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxTypedModelNode_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
+				symbol_0 = logDiagnostic;
+			}
+			return Boolean.TRUE == symbol_0;
 		}
-		else {
-			final /*@NonInvalid*/ java.lang.@Nullable String name = this.getName();
-			final /*@NonInvalid*/ boolean result = name != null;
-			final /*@NonInvalid*/ boolean logDiagnostic = CGStringLogDiagnosticOperation.INSTANCE.evaluate(executor, TypeId.BOOLEAN, UMLXTables.STR_TxTypedModelNode_c_c_NameIsRequired, this, (Object)null, diagnostics, context, (Object)null, severity_0, result, UMLXTables.INT_0).booleanValue();
-			symbol_0 = logDiagnostic;
+		catch (Throwable e) {
+			return ValueUtil.validationFailedDiagnostic("TxTypedModelNode::NameIsRequired", this, diagnostics, context, e);
 		}
-		return Boolean.TRUE == symbol_0;
 	}
 
 	/**
@@ -411,7 +429,7 @@
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				if (eInternalContainer() != null)
 					msgs = eBasicRemoveFromContainer(msgs);
 				return basicSetOwningTxDiagram((TxDiagram)otherEnd, msgs);
@@ -427,7 +445,7 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				return basicSetOwningTxDiagram(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -441,8 +459,8 @@
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM:
-				return eInternalContainer().eInverseRemove(this, UMLXPackage.TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES, TxDiagram.class, msgs);
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
+				return eInternalContainer().eInverseRemove(this, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4, TxDiagram.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -455,17 +473,17 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.TX_TYPED_MODEL_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return getName();
-			case UMLXPackage.TX_TYPED_MODEL_NODE__CHECK:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return isCheck();
-			case UMLXPackage.TX_TYPED_MODEL_NODE__DEPENDS_ONS:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				return getDependsOns();
-			case UMLXPackage.TX_TYPED_MODEL_NODE__ENFORCE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				return isEnforce();
-			case UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				return getOwningTxDiagram();
-			case UMLXPackage.TX_TYPED_MODEL_NODE__USED_TX_PACKAGE_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				return getUsedTxPackageNodes();
 		}
 		return super.eGet(featureID, resolve, coreType);
@@ -480,23 +498,23 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.TX_TYPED_MODEL_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				setName((String)newValue);
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__CHECK:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setCheck((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__DEPENDS_ONS:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				getDependsOns().clear();
 				getDependsOns().addAll((Collection<? extends TxTypedModelNode>)newValue);
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__ENFORCE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				setEnforce((Boolean)newValue);
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				setOwningTxDiagram((TxDiagram)newValue);
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__USED_TX_PACKAGE_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				getUsedTxPackageNodes().clear();
 				getUsedTxPackageNodes().addAll((Collection<? extends TxPackageNode>)newValue);
 				return;
@@ -512,22 +530,22 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_TYPED_MODEL_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				setName(NAME_EDEFAULT);
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__CHECK:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				setCheck(CHECK_EDEFAULT);
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__DEPENDS_ONS:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				getDependsOns().clear();
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__ENFORCE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				setEnforce(ENFORCE_EDEFAULT);
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				setOwningTxDiagram((TxDiagram)null);
 				return;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__USED_TX_PACKAGE_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				getUsedTxPackageNodes().clear();
 				return;
 		}
@@ -542,17 +560,17 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.TX_TYPED_MODEL_NODE__NAME:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0:
 				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case UMLXPackage.TX_TYPED_MODEL_NODE__CHECK:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 1:
 				return check != CHECK_EDEFAULT;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__DEPENDS_ONS:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 2:
 				return dependsOns != null && !dependsOns.isEmpty();
-			case UMLXPackage.TX_TYPED_MODEL_NODE__ENFORCE:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 3:
 				return enforce != ENFORCE_EDEFAULT;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 4:
 				return getOwningTxDiagram() != null;
-			case UMLXPackage.TX_TYPED_MODEL_NODE__USED_TX_PACKAGE_NODES:
+			case TxNodeImpl.TX_NODE_FEATURE_COUNT + 5:
 				return usedTxPackageNodes != null && !usedTxPackageNodes.isEmpty();
 		}
 		return super.eIsSet(featureID);
@@ -567,7 +585,7 @@
 	public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) {
 		if (baseClass == UMLXNamedElement.class) {
 			switch (derivedFeatureID) {
-				case UMLXPackage.TX_TYPED_MODEL_NODE__NAME: return UMLXPackage.UMLX_NAMED_ELEMENT__NAME;
+				case TxNodeImpl.TX_NODE_FEATURE_COUNT + 0: return UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0;
 				default: return -1;
 			}
 		}
@@ -583,7 +601,7 @@
 	public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) {
 		if (baseClass == UMLXNamedElement.class) {
 			switch (baseFeatureID) {
-				case UMLXPackage.UMLX_NAMED_ELEMENT__NAME: return UMLXPackage.TX_TYPED_MODEL_NODE__NAME;
+				case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0: return TxNodeImpl.TX_NODE_FEATURE_COUNT + 0;
 				default: return -1;
 			}
 		}
@@ -606,7 +624,17 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: ");
+		result.append(name);
+		result.append(", check: ");
+		result.append(check);
+		result.append(", enforce: ");
+		result.append(enforce);
+		result.append(')');
+		return result.toString();
 	}
 
 } //TxTypedModelNodeImpl
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXElementImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXElementImpl.java
index ce786f4..3af267e 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXElementImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXElementImpl.java
@@ -21,7 +21,6 @@
 import org.eclipse.qvtd.umlx.UMLXElement;
 import org.eclipse.qvtd.umlx.UMLXPackage;
 import org.eclipse.qvtd.umlx.util.UMLXVisitor;
-import org.eclipse.qvtd.umlx.utilities.UMLXToStringVisitor;
 
 /**
  * <!-- begin-user-doc -->
@@ -38,6 +37,14 @@
  */
 public abstract class UMLXElementImpl extends MinimalEObjectImpl.Container implements UMLXElement {
 	/**
+	 * The number of structural features of the '<em>Element</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int UMLX_ELEMENT_FEATURE_COUNT = 1;
+	/**
 	 * The cached value of the '{@link #getComments() <em>Comments</em>}' attribute list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -74,7 +81,7 @@
 	@Override
 	public EList<String> getComments() {
 		if (comments == null) {
-			comments = new EDataTypeUniqueEList<String>(String.class, this, UMLXPackage.UMLX_ELEMENT__COMMENTS);
+			comments = new EDataTypeUniqueEList<String>(String.class, this, 0);
 		}
 		return comments;
 	}
@@ -86,7 +93,13 @@
 	 */
 	@Override
 	public String toString() {
-		return UMLXToStringVisitor.toString(this);
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (comments: ");
+		result.append(comments);
+		result.append(')');
+		return result.toString();
 	}
 
 	@Override
@@ -106,7 +119,7 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_ELEMENT__COMMENTS:
+			case 0:
 				return getComments();
 		}
 		return super.eGet(featureID, resolve, coreType);
@@ -121,7 +134,7 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_ELEMENT__COMMENTS:
+			case 0:
 				getComments().clear();
 				getComments().addAll((Collection<? extends String>)newValue);
 				return;
@@ -137,7 +150,7 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_ELEMENT__COMMENTS:
+			case 0:
 				getComments().clear();
 				return;
 		}
@@ -152,7 +165,7 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_ELEMENT__COMMENTS:
+			case 0:
 				return comments != null && !comments.isEmpty();
 		}
 		return super.eIsSet(featureID);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXFactoryImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXFactoryImpl.java
index 023f34b..7a25a3c 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXFactoryImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXFactoryImpl.java
@@ -64,21 +64,21 @@
 	@Override
 	public EObject create(EClass eClass) {
 		switch (eClass.getClassifierID()) {
-			case UMLXPackage.REL_DIAGRAM: return createRelDiagram();
-			case UMLXPackage.REL_DOMAIN_NODE: return createRelDomainNode();
-			case UMLXPackage.REL_INVOCATION_EDGE: return createRelInvocationEdge();
-			case UMLXPackage.REL_INVOCATION_NODE: return createRelInvocationNode();
-			case UMLXPackage.REL_PATTERN_EDGE: return createRelPatternEdge();
-			case UMLXPackage.REL_PATTERN_NODE: return createRelPatternNode();
-			case UMLXPackage.TX_DIAGRAM: return createTxDiagram();
-			case UMLXPackage.TX_KEY_NODE: return createTxKeyNode();
-			case UMLXPackage.TX_NODE: return createTxNode();
-			case UMLXPackage.TX_PACKAGE_NODE: return createTxPackageNode();
-			case UMLXPackage.TX_PARAMETER_NODE: return createTxParameterNode();
-			case UMLXPackage.TX_PART_NODE: return createTxPartNode();
-			case UMLXPackage.TX_QUERY_NODE: return createTxQueryNode();
-			case UMLXPackage.TX_TYPED_MODEL_NODE: return createTxTypedModelNode();
-			case UMLXPackage.UMLX_MODEL: return createUMLXModel();
+			case 0: return createRelDiagram();
+			case 1: return createRelDomainNode();
+			case 3: return createRelInvocationEdge();
+			case 4: return createRelInvocationNode();
+			case 6: return createRelPatternEdge();
+			case 7: return createRelPatternNode();
+			case 8: return createTxDiagram();
+			case 9: return createTxKeyNode();
+			case 10: return createTxNode();
+			case 11: return createTxPackageNode();
+			case 12: return createTxParameterNode();
+			case 13: return createTxPartNode();
+			case 14: return createTxQueryNode();
+			case 15: return createTxTypedModelNode();
+			case 17: return createUMLXModel();
 			default:
 				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
 		}
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXModelImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXModelImpl.java
index fab32ca..fe4e9b8 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXModelImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXModelImpl.java
@@ -39,6 +39,14 @@
  */
 public class UMLXModelImpl extends UMLXElementImpl implements UMLXModel {
 	/**
+	 * The number of structural features of the '<em>Model</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int UMLX_MODEL_FEATURE_COUNT = UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 1;
+	/**
 	 * The cached value of the '{@link #getOwnedTxDiagrams() <em>Owned Tx Diagrams</em>}' containment reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -74,7 +82,7 @@
 	@Override
 	public EList<TxDiagram> getOwnedTxDiagrams() {
 		if (ownedTxDiagrams == null) {
-			ownedTxDiagrams = new EObjectContainmentEList<TxDiagram>(TxDiagram.class, this, UMLXPackage.UMLX_MODEL__OWNED_TX_DIAGRAMS);
+			ownedTxDiagrams = new EObjectContainmentEList<TxDiagram>(TxDiagram.class, this, UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0);
 		}
 		return ownedTxDiagrams;
 	}
@@ -87,7 +95,7 @@
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_MODEL__OWNED_TX_DIAGRAMS:
+			case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0:
 				return ((InternalEList<?>)getOwnedTxDiagrams()).basicRemove(otherEnd, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
@@ -101,7 +109,7 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_MODEL__OWNED_TX_DIAGRAMS:
+			case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0:
 				return getOwnedTxDiagrams();
 		}
 		return super.eGet(featureID, resolve, coreType);
@@ -116,7 +124,7 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_MODEL__OWNED_TX_DIAGRAMS:
+			case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0:
 				getOwnedTxDiagrams().clear();
 				getOwnedTxDiagrams().addAll((Collection<? extends TxDiagram>)newValue);
 				return;
@@ -132,7 +140,7 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_MODEL__OWNED_TX_DIAGRAMS:
+			case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0:
 				getOwnedTxDiagrams().clear();
 				return;
 		}
@@ -147,7 +155,7 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_MODEL__OWNED_TX_DIAGRAMS:
+			case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0:
 				return ownedTxDiagrams != null && !ownedTxDiagrams.isEmpty();
 		}
 		return super.eIsSet(featureID);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXNamedElementImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXNamedElementImpl.java
index 64f2981..f66a74a 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXNamedElementImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXNamedElementImpl.java
@@ -31,6 +31,15 @@
  */
 public abstract class UMLXNamedElementImpl extends UMLXElementImpl implements UMLXNamedElement {
 	/**
+	 * The number of structural features of the '<em>Named Element</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int UMLX_NAMED_ELEMENT_FEATURE_COUNT = UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 1;
+
+	/**
 	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -89,7 +98,7 @@
 		String oldName = name;
 		name = newName;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.UMLX_NAMED_ELEMENT__NAME, oldName, name));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0, oldName, name));
 	}
 
 	/**
@@ -99,7 +108,13 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: ");
+		result.append(name);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -110,7 +125,7 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_NAMED_ELEMENT__NAME:
+			case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0:
 				return getName();
 		}
 		return super.eGet(featureID, resolve, coreType);
@@ -124,7 +139,7 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_NAMED_ELEMENT__NAME:
+			case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0:
 				setName((String)newValue);
 				return;
 		}
@@ -139,7 +154,7 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_NAMED_ELEMENT__NAME:
+			case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0:
 				setName(NAME_EDEFAULT);
 				return;
 		}
@@ -154,7 +169,7 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_NAMED_ELEMENT__NAME:
+			case UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0:
 				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
 		}
 		return super.eIsSet(featureID);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXPackageImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXPackageImpl.java
index 1d8baf2..36312b7 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXPackageImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXPackageImpl.java
@@ -231,8 +231,8 @@
 		if (isInited) return (UMLXPackage)EPackage.Registry.INSTANCE.getEPackage(UMLXPackage.eNS_URI);
 
 		// Obtain or create and register package
-		Object ePackage = EPackage.Registry.INSTANCE.get(eNS_URI);
-		UMLXPackageImpl theUMLXPackage = (UMLXPackageImpl)(ePackage instanceof UMLXPackageImpl ? ePackage : new UMLXPackageImpl());
+		Object registeredUMLXPackage = EPackage.Registry.INSTANCE.get(eNS_URI);
+		UMLXPackageImpl theUMLXPackage = registeredUMLXPackage instanceof UMLXPackageImpl ? (UMLXPackageImpl)registeredUMLXPackage : new UMLXPackageImpl();
 
 		isInited = true;
 
@@ -244,18 +244,17 @@
 
 		// Register package validator
 		EValidator.Registry.INSTANCE.put
-		(theUMLXPackage,
-			new EValidator.Descriptor() {
-			@Override
-			public EValidator getEValidator() {
-				return UMLXValidator.INSTANCE;
-			}
-		});
+			(theUMLXPackage,
+			 new EValidator.Descriptor() {
+				 @Override
+				 public EValidator getEValidator() {
+					 return UMLXValidator.INSTANCE;
+				 }
+			 });
 
 		// Mark meta-data to indicate it can't be changed
 		theUMLXPackage.freeze();
 
-
 		// Update the registry and return the package
 		EPackage.Registry.INSTANCE.put(UMLXPackage.eNS_URI, theUMLXPackage);
 		return theUMLXPackage;
@@ -1110,107 +1109,107 @@
 		isCreated = true;
 
 		// Create classes and their features
-		relDiagramEClass = createEClass(REL_DIAGRAM);
-		createEAttribute(relDiagramEClass, REL_DIAGRAM__IS_ABSTRACT);
-		createEAttribute(relDiagramEClass, REL_DIAGRAM__IS_TOP);
-		createEReference(relDiagramEClass, REL_DIAGRAM__OWNED_REL_DOMAIN_NODES);
-		createEReference(relDiagramEClass, REL_DIAGRAM__OWNED_REL_INVOCATION_NODES);
-		createEReference(relDiagramEClass, REL_DIAGRAM__OWNING_TX_DIAGRAM);
+		relDiagramEClass = createEClass(0);
+		createEAttribute(relDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0);
+		createEAttribute(relDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1);
+		createEReference(relDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2);
+		createEReference(relDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3);
+		createEReference(relDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4);
 
-		relDomainNodeEClass = createEClass(REL_DOMAIN_NODE);
-		createEAttribute(relDomainNodeEClass, REL_DOMAIN_NODE__IS_ENFORCED);
-		createEReference(relDomainNodeEClass, REL_DOMAIN_NODE__OWNED_REL_PATTERN_EDGES);
-		createEReference(relDomainNodeEClass, REL_DOMAIN_NODE__OWNED_REL_PATTERN_NODES);
-		createEReference(relDomainNodeEClass, REL_DOMAIN_NODE__OWNING_REL_DIAGRAM);
-		createEReference(relDomainNodeEClass, REL_DOMAIN_NODE__REFERRED_TX_TYPED_MODEL_NODE);
+		relDomainNodeEClass = createEClass(1);
+		createEAttribute(relDomainNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 0);
+		createEReference(relDomainNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 1);
+		createEReference(relDomainNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 2);
+		createEReference(relDomainNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 3);
+		createEReference(relDomainNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 4);
 
-		relEdgeEClass = createEClass(REL_EDGE);
+		relEdgeEClass = createEClass(2);
 
-		relInvocationEdgeEClass = createEClass(REL_INVOCATION_EDGE);
-		createEReference(relInvocationEdgeEClass, REL_INVOCATION_EDGE__INVOKING_REL_PATTERN_NODE);
-		createEReference(relInvocationEdgeEClass, REL_INVOCATION_EDGE__OWNING_REL_INVOCATION_NODE);
-		createEReference(relInvocationEdgeEClass, REL_INVOCATION_EDGE__REFERRED_REL_PATTERN_NODE);
+		relInvocationEdgeEClass = createEClass(3);
+		createEReference(relInvocationEdgeEClass, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0);
+		createEReference(relInvocationEdgeEClass, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1);
+		createEReference(relInvocationEdgeEClass, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2);
 
-		relInvocationNodeEClass = createEClass(REL_INVOCATION_NODE);
-		createEAttribute(relInvocationNodeEClass, REL_INVOCATION_NODE__IS_THEN);
-		createEReference(relInvocationNodeEClass, REL_INVOCATION_NODE__OWNING_REL_DIAGRAM);
-		createEReference(relInvocationNodeEClass, REL_INVOCATION_NODE__OWNED_REL_INVOCATION_EDGES);
-		createEReference(relInvocationNodeEClass, REL_INVOCATION_NODE__REFERRED_REL_DIAGRAM);
+		relInvocationNodeEClass = createEClass(4);
+		createEAttribute(relInvocationNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 0);
+		createEReference(relInvocationNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 1);
+		createEReference(relInvocationNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 2);
+		createEReference(relInvocationNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 3);
 
-		relNodeEClass = createEClass(REL_NODE);
+		relNodeEClass = createEClass(5);
 
-		relPatternEdgeEClass = createEClass(REL_PATTERN_EDGE);
-		createEReference(relPatternEdgeEClass, REL_PATTERN_EDGE__OWNING_REL_DOMAIN_NODE);
-		createEReference(relPatternEdgeEClass, REL_PATTERN_EDGE__REFERRED_ESTRUCTURAL_FEATURE);
-		createEReference(relPatternEdgeEClass, REL_PATTERN_EDGE__SOURCE);
-		createEAttribute(relPatternEdgeEClass, REL_PATTERN_EDGE__SOURCE_INDEX);
-		createEReference(relPatternEdgeEClass, REL_PATTERN_EDGE__TARGET);
+		relPatternEdgeEClass = createEClass(6);
+		createEReference(relPatternEdgeEClass, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 0);
+		createEReference(relPatternEdgeEClass, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 1);
+		createEReference(relPatternEdgeEClass, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 2);
+		createEAttribute(relPatternEdgeEClass, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 3);
+		createEReference(relPatternEdgeEClass, RelEdgeImpl.REL_EDGE_FEATURE_COUNT + 4);
 
-		relPatternNodeEClass = createEClass(REL_PATTERN_NODE);
-		createEReference(relPatternNodeEClass, REL_PATTERN_NODE__INCOMING);
-		createEAttribute(relPatternNodeEClass, REL_PATTERN_NODE__INIT_EXPRESSION_LINES);
-		createEReference(relPatternNodeEClass, REL_PATTERN_NODE__INVOKING_REL_INVOCATION_EDGES);
-		createEAttribute(relPatternNodeEClass, REL_PATTERN_NODE__IS_ANON);
-		createEAttribute(relPatternNodeEClass, REL_PATTERN_NODE__IS_ROOT);
-		createEReference(relPatternNodeEClass, REL_PATTERN_NODE__OUTGOING);
-		createEReference(relPatternNodeEClass, REL_PATTERN_NODE__OWNING_REL_DOMAIN_NODE);
+		relPatternNodeEClass = createEClass(7);
+		createEReference(relPatternNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 7);
+		createEAttribute(relPatternNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 8);
+		createEReference(relPatternNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 9);
+		createEAttribute(relPatternNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 10);
+		createEAttribute(relPatternNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 11);
+		createEReference(relPatternNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 12);
+		createEReference(relPatternNodeEClass, RelNodeImpl.REL_NODE_FEATURE_COUNT + 13);
 
-		txDiagramEClass = createEClass(TX_DIAGRAM);
-		createEReference(txDiagramEClass, TX_DIAGRAM__OWNED_REL_DIAGRAMS);
-		createEReference(txDiagramEClass, TX_DIAGRAM__OWNED_TX_KEY_NODES);
-		createEReference(txDiagramEClass, TX_DIAGRAM__OWNED_TX_PACKAGE_NODES);
-		createEReference(txDiagramEClass, TX_DIAGRAM__OWNED_TX_QUERY_NODES);
-		createEReference(txDiagramEClass, TX_DIAGRAM__OWNED_TX_TYPED_MODEL_NODES);
-		createEAttribute(txDiagramEClass, TX_DIAGRAM__PACKAGE);
+		txDiagramEClass = createEClass(8);
+		createEReference(txDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0);
+		createEReference(txDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1);
+		createEReference(txDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2);
+		createEReference(txDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3);
+		createEReference(txDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4);
+		createEAttribute(txDiagramEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5);
 
-		txKeyNodeEClass = createEClass(TX_KEY_NODE);
-		createEReference(txKeyNodeEClass, TX_KEY_NODE__OWNED_TX_PART_NODES);
-		createEReference(txKeyNodeEClass, TX_KEY_NODE__OWNING_TX_DIAGRAM);
-		createEReference(txKeyNodeEClass, TX_KEY_NODE__REFERRED_ECLASS);
+		txKeyNodeEClass = createEClass(9);
+		createEReference(txKeyNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0);
+		createEReference(txKeyNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1);
+		createEReference(txKeyNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2);
 
-		txNodeEClass = createEClass(TX_NODE);
+		txNodeEClass = createEClass(10);
 
-		txPackageNodeEClass = createEClass(TX_PACKAGE_NODE);
-		createEAttribute(txPackageNodeEClass, TX_PACKAGE_NODE__IMPORT_ALIASES);
-		createEReference(txPackageNodeEClass, TX_PACKAGE_NODE__OWNING_TX_DIAGRAM);
-		createEReference(txPackageNodeEClass, TX_PACKAGE_NODE__REFERRED_EPACKAGE);
+		txPackageNodeEClass = createEClass(11);
+		createEAttribute(txPackageNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0);
+		createEReference(txPackageNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1);
+		createEReference(txPackageNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2);
 
-		txParameterNodeEClass = createEClass(TX_PARAMETER_NODE);
-		createEReference(txParameterNodeEClass, TX_PARAMETER_NODE__OWNING_TX_QUERY_NODE);
+		txParameterNodeEClass = createEClass(12);
+		createEReference(txParameterNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 7);
 
-		txPartNodeEClass = createEClass(TX_PART_NODE);
-		createEReference(txPartNodeEClass, TX_PART_NODE__OWNING_TX_KEY_NODE);
-		createEAttribute(txPartNodeEClass, TX_PART_NODE__IS_OPPOSITE);
-		createEReference(txPartNodeEClass, TX_PART_NODE__REFERRED_ESTRUCTURAL_FEATURE);
+		txPartNodeEClass = createEClass(13);
+		createEReference(txPartNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 0);
+		createEAttribute(txPartNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1);
+		createEReference(txPartNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2);
 
-		txQueryNodeEClass = createEClass(TX_QUERY_NODE);
-		createEAttribute(txQueryNodeEClass, TX_QUERY_NODE__INIT_EXPRESSION_LINES);
-		createEReference(txQueryNodeEClass, TX_QUERY_NODE__OWNED_TX_PARAMETER_NODES);
-		createEReference(txQueryNodeEClass, TX_QUERY_NODE__OWNING_TX_DIAGRAM);
+		txQueryNodeEClass = createEClass(14);
+		createEAttribute(txQueryNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 7);
+		createEReference(txQueryNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 8);
+		createEReference(txQueryNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 9);
 
-		txTypedModelNodeEClass = createEClass(TX_TYPED_MODEL_NODE);
-		createEAttribute(txTypedModelNodeEClass, TX_TYPED_MODEL_NODE__CHECK);
-		createEReference(txTypedModelNodeEClass, TX_TYPED_MODEL_NODE__DEPENDS_ONS);
-		createEAttribute(txTypedModelNodeEClass, TX_TYPED_MODEL_NODE__ENFORCE);
-		createEReference(txTypedModelNodeEClass, TX_TYPED_MODEL_NODE__OWNING_TX_DIAGRAM);
-		createEReference(txTypedModelNodeEClass, TX_TYPED_MODEL_NODE__USED_TX_PACKAGE_NODES);
+		txTypedModelNodeEClass = createEClass(15);
+		createEAttribute(txTypedModelNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 1);
+		createEReference(txTypedModelNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 2);
+		createEAttribute(txTypedModelNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 3);
+		createEReference(txTypedModelNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 4);
+		createEReference(txTypedModelNodeEClass, TxNodeImpl.TX_NODE_FEATURE_COUNT + 5);
 
-		umlxElementEClass = createEClass(UMLX_ELEMENT);
-		createEAttribute(umlxElementEClass, UMLX_ELEMENT__COMMENTS);
+		umlxElementEClass = createEClass(16);
+		createEAttribute(umlxElementEClass, 0);
 
-		umlxModelEClass = createEClass(UMLX_MODEL);
-		createEReference(umlxModelEClass, UMLX_MODEL__OWNED_TX_DIAGRAMS);
+		umlxModelEClass = createEClass(17);
+		createEReference(umlxModelEClass, UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0);
 
-		umlxNamedElementEClass = createEClass(UMLX_NAMED_ELEMENT);
-		createEAttribute(umlxNamedElementEClass, UMLX_NAMED_ELEMENT__NAME);
+		umlxNamedElementEClass = createEClass(18);
+		createEAttribute(umlxNamedElementEClass, UMLXElementImpl.UMLX_ELEMENT_FEATURE_COUNT + 0);
 
-		umlxTypedElementEClass = createEClass(UMLX_TYPED_ELEMENT);
-		createEAttribute(umlxTypedElementEClass, UMLX_TYPED_ELEMENT__IS_MANY);
-		createEAttribute(umlxTypedElementEClass, UMLX_TYPED_ELEMENT__IS_NULL_FREE);
-		createEAttribute(umlxTypedElementEClass, UMLX_TYPED_ELEMENT__IS_ORDERED);
-		createEAttribute(umlxTypedElementEClass, UMLX_TYPED_ELEMENT__IS_REQUIRED);
-		createEAttribute(umlxTypedElementEClass, UMLX_TYPED_ELEMENT__IS_UNIQUE);
-		createEReference(umlxTypedElementEClass, UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER);
+		umlxTypedElementEClass = createEClass(19);
+		createEAttribute(umlxTypedElementEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0);
+		createEAttribute(umlxTypedElementEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1);
+		createEAttribute(umlxTypedElementEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2);
+		createEAttribute(umlxTypedElementEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3);
+		createEAttribute(umlxTypedElementEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4);
+		createEReference(umlxTypedElementEClass, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5);
 	}
 
 	/**
@@ -1630,6 +1629,8 @@
 		createEcoreAnnotations();
 		// http://www.eclipse.org/uml2/2.0.0/UML
 		createUMLAnnotations();
+		// http://www.eclipse.org/emf/2002/Ecore/OCL/Pivot
+		createPivotAnnotations();
 	}
 
 	/**
@@ -1641,70 +1642,70 @@
 	protected void createEcoreAnnotations() {
 		String source = "http://www.eclipse.org/emf/2002/Ecore";
 		addAnnotation
-		(this,
-			source,
-			new String[] {
-		});
+		  (this,
+		   source,
+		   new String[] {
+		   });
 		addAnnotation
-		(relDiagramEClass,
-			source,
-			new String[] {
-				"constraints", "validateRelPatternNodeNamesAreUnique"
-		});
+		  (relDiagramEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validateRelPatternNodeNamesAreUnique"
+		   });
 		addAnnotation
-		(relInvocationNodeEClass,
-			source,
-			new String[] {
-				"constraints", "validateCompatibleEdges"
-		});
+		  (relInvocationNodeEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validateCompatibleEdges"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass,
-			source,
-			new String[] {
-				"constraints", "validateCompatibleMemberPropertyTarget"
-		});
+		  (relPatternEdgeEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validateCompatibleMemberPropertyTarget"
+		   });
 		addAnnotation
-		(relPatternNodeEClass,
-			source,
-			new String[] {
-				"constraints", "validateEClassifierIsInTypedModel"
-		});
+		  (relPatternNodeEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validateEClassifierIsInTypedModel"
+		   });
 		addAnnotation
-		(txDiagramEClass,
-			source,
-			new String[] {
-				"constraints", "validateTxTypedModelNodeNamesAreUnique"
-		});
+		  (txDiagramEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validateTxTypedModelNodeNamesAreUnique"
+		   });
 		addAnnotation
-		(txKeyNodeEClass,
-			source,
-			new String[] {
-				"constraints", "validatePartsAreUnique"
-		});
+		  (txKeyNodeEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validatePartsAreUnique"
+		   });
 		addAnnotation
-		(txParameterNodeEClass,
-			source,
-			new String[] {
-				"constraints", "validateTypeIsRequired"
-		});
+		  (txParameterNodeEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validateTypeIsRequired"
+		   });
 		addAnnotation
-		(txPartNodeEClass,
-			source,
-			new String[] {
-				"constraints", "validatePartIsPropertyOfKey"
-		});
+		  (txPartNodeEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validatePartIsPropertyOfKey"
+		   });
 		addAnnotation
-		(txQueryNodeEClass,
-			source,
-			new String[] {
-				"constraints", "validateParametersAreUnique"
-		});
+		  (txQueryNodeEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validateParametersAreUnique"
+		   });
 		addAnnotation
-		(txTypedModelNodeEClass,
-			source,
-			new String[] {
-				"constraints", "validateNameIsRequired"
-		});
+		  (txTypedModelNodeEClass,
+		   source,
+		   new String[] {
+			   "constraints", "validateNameIsRequired"
+		   });
 	}
 
 	/**
@@ -1716,173 +1717,357 @@
 	protected void createUMLAnnotations() {
 		String source = "http://www.eclipse.org/uml2/2.0.0/UML";
 		addAnnotation
-		(relDiagramEClass.getEOperations().get(0),
-			source,
-			new String[] {
-				"originalName", "NameIsRequired"
-		});
+		  (relDiagramEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "originalName", "NameIsRequired"
+		   });
 		addAnnotation
-		(relDiagramEClass.getEOperations().get(1),
-			source,
-			new String[] {
-				"originalName", "RelPatternNodeNamesAreUnique"
-		});
+		  (relDiagramEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "originalName", "RelPatternNodeNamesAreUnique"
+		   });
 		addAnnotation
-		(relInvocationNodeEClass.getEOperations().get(0),
-			source,
-			new String[] {
-				"originalName", "CompatibleEdges"
-		});
+		  (relInvocationNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "originalName", "CompatibleEdges"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass.getEOperations().get(0),
-			source,
-			new String[] {
-				"originalName", "SourceIsEClass"
-		});
+		  (relPatternEdgeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "originalName", "SourceIsEClass"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass.getEOperations().get(1),
-			source,
-			new String[] {
-				"originalName", "SourceIsClassNode"
-		});
+		  (relPatternEdgeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "originalName", "SourceIsClassNode"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass.getEOperations().get(2),
-			source,
-			new String[] {
-				"originalName", "CompatibleEAttributePropertyTarget"
-		});
+		  (relPatternEdgeEClass.getEOperations().get(2),
+		   source,
+		   new String[] {
+			   "originalName", "CompatibleEAttributePropertyTarget"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass.getEOperations().get(3),
-			source,
-			new String[] {
-				"originalName", "CompatibleSourceMultiplicity"
-		});
+		  (relPatternEdgeEClass.getEOperations().get(3),
+		   source,
+		   new String[] {
+			   "originalName", "CompatibleSourceMultiplicity"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass.getEOperations().get(4),
-			source,
-			new String[] {
-				"originalName", "CompatibleEReferencePropertyTarget"
-		});
+		  (relPatternEdgeEClass.getEOperations().get(4),
+		   source,
+		   new String[] {
+			   "originalName", "CompatibleEReferencePropertyTarget"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass.getEOperations().get(5),
-			source,
-			new String[] {
-				"originalName", "CompatiblePropertySource"
-		});
+		  (relPatternEdgeEClass.getEOperations().get(5),
+		   source,
+		   new String[] {
+			   "originalName", "CompatiblePropertySource"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass.getEOperations().get(6),
-			source,
-			new String[] {
-				"originalName", "CompatibleSourceIndex"
-		});
+		  (relPatternEdgeEClass.getEOperations().get(6),
+		   source,
+		   new String[] {
+			   "originalName", "CompatibleSourceIndex"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass.getEOperations().get(7),
-			source,
-			new String[] {
-				"originalName", "CompatibleRestPropertyTarget"
-		});
+		  (relPatternEdgeEClass.getEOperations().get(7),
+		   source,
+		   new String[] {
+			   "originalName", "CompatibleRestPropertyTarget"
+		   });
 		addAnnotation
-		(relPatternEdgeEClass.getEOperations().get(8),
-			source,
-			new String[] {
-				"originalName", "CompatibleMemberPropertyTarget"
-		});
+		  (relPatternEdgeEClass.getEOperations().get(8),
+		   source,
+		   new String[] {
+			   "originalName", "CompatibleMemberPropertyTarget"
+		   });
 		addAnnotation
-		(relPatternNodeEClass.getEOperations().get(1),
-			source,
-			new String[] {
-				"originalName", "AnonIsUnnamed"
-		});
+		  (relPatternNodeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "originalName", "AnonIsUnnamed"
+		   });
 		addAnnotation
-		(relPatternNodeEClass.getEOperations().get(2),
-			source,
-			new String[] {
-				"originalName", "TypeIsRequired"
-		});
+		  (relPatternNodeEClass.getEOperations().get(2),
+		   source,
+		   new String[] {
+			   "originalName", "TypeIsRequired"
+		   });
 		addAnnotation
-		(relPatternNodeEClass.getEOperations().get(3),
-			source,
-			new String[] {
-				"originalName", "EClassifierIsInTypedModel"
-		});
+		  (relPatternNodeEClass.getEOperations().get(3),
+		   source,
+		   new String[] {
+			   "originalName", "EClassifierIsInTypedModel"
+		   });
 		addAnnotation
-		(txDiagramEClass.getEOperations().get(0),
-			source,
-			new String[] {
-				"originalName", "TxQueryNodeNamesAreUnique"
-		});
+		  (txDiagramEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "originalName", "TxQueryNodeNamesAreUnique"
+		   });
 		addAnnotation
-		(txDiagramEClass.getEOperations().get(1),
-			source,
-			new String[] {
-				"originalName", "RelDiagramNamesAreUnique"
-		});
+		  (txDiagramEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "originalName", "RelDiagramNamesAreUnique"
+		   });
 		addAnnotation
-		(txDiagramEClass.getEOperations().get(2),
-			source,
-			new String[] {
-				"originalName", "NameIsRequired"
-		});
+		  (txDiagramEClass.getEOperations().get(2),
+		   source,
+		   new String[] {
+			   "originalName", "NameIsRequired"
+		   });
 		addAnnotation
-		(txDiagramEClass.getEOperations().get(3),
-			source,
-			new String[] {
-				"originalName", "TxTypedModelNodeNamesAreUnique"
-		});
+		  (txDiagramEClass.getEOperations().get(3),
+		   source,
+		   new String[] {
+			   "originalName", "TxTypedModelNodeNamesAreUnique"
+		   });
 		addAnnotation
-		(txKeyNodeEClass.getEOperations().get(0),
-			source,
-			new String[] {
-				"originalName", "PartsAreUnique"
-		});
+		  (txKeyNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "originalName", "PartsAreUnique"
+		   });
 		addAnnotation
-		(txParameterNodeEClass.getEOperations().get(0),
-			source,
-			new String[] {
-				"originalName", "NameIsRequired"
-		});
+		  (txParameterNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "originalName", "NameIsRequired"
+		   });
 		addAnnotation
-		(txParameterNodeEClass.getEOperations().get(1),
-			source,
-			new String[] {
-				"originalName", "TypeIsRequired"
-		});
+		  (txParameterNodeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "originalName", "TypeIsRequired"
+		   });
 		addAnnotation
-		(txPartNodeEClass.getEOperations().get(0),
-			source,
-			new String[] {
-				"originalName", "PartIsPropertyOfKey"
-		});
+		  (txPartNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "originalName", "PartIsPropertyOfKey"
+		   });
 		addAnnotation
-		(txQueryNodeEClass.getEOperations().get(0),
-			source,
-			new String[] {
-				"originalName", "NameIsRequired"
-		});
+		  (txQueryNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "originalName", "NameIsRequired"
+		   });
 		addAnnotation
-		(txQueryNodeEClass.getEOperations().get(1),
-			source,
-			new String[] {
-				"originalName", "TypeIsRequired"
-		});
+		  (txQueryNodeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "originalName", "TypeIsRequired"
+		   });
 		addAnnotation
-		(txQueryNodeEClass.getEOperations().get(2),
-			source,
-			new String[] {
-				"originalName", "ParametersAreUnique"
-		});
+		  (txQueryNodeEClass.getEOperations().get(2),
+		   source,
+		   new String[] {
+			   "originalName", "ParametersAreUnique"
+		   });
 		addAnnotation
-		(txTypedModelNodeEClass.getEOperations().get(0),
-			source,
-			new String[] {
-				"originalName", "TxPackageNodePackagesAreUnique"
-		});
+		  (txTypedModelNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "originalName", "TxPackageNodePackagesAreUnique"
+		   });
 		addAnnotation
-		(txTypedModelNodeEClass.getEOperations().get(1),
-			source,
-			new String[] {
-				"originalName", "NameIsRequired"
-		});
+		  (txTypedModelNodeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "originalName", "NameIsRequired"
+		   });
+	}
+
+	/**
+	 * Initializes the annotations for <b>http://www.eclipse.org/emf/2002/Ecore/OCL/Pivot</b>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void createPivotAnnotations() {
+		String source = "http://www.eclipse.org/emf/2002/Ecore/OCL/Pivot";
+		addAnnotation
+		  (relDiagramEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "name <> null"
+		   });
+		addAnnotation
+		  (relDiagramEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "body", "let allNames = ownedRelDomainNodes.ownedRelPatternNodes->select(not isExpression())->select(not isAnon).name in\n\t\tTuple{status : Boolean = allNames->isUnique(n | n),\n\t\t\tmessage : String = let repeatedNames = allNames->select(n | allNames->count(n) > 1)->asSet() in\n\t\t\trepeatedNames->iterate(n; acc:String = \'RelDiagram::RelPatternNodeNamesAreUnique:\' | acc + \' \\\'\' + n + \'\\\'\') + \' are not unique for \' + name\n\t\t}.status"
+		   });
+		addAnnotation
+		  (relInvocationNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\tlet expectedNodes = referredRelDiagram.ownedRelDomainNodes.ownedRelPatternNodes->select(isRoot)->asSet() in\n\t\t\tlet actualNodes = ownedRelInvocationEdges.referredRelPatternNode->asSet() in\t\t\n\t\t\tTuple{status : Boolean = expectedNodes = actualNodes,\n\t\t\t\tmessage : String = \'RelInvocationNode::CompatibleEdges \' + expectedNodes->size().toString() + \'/\' + expectedNodes->size().toString()\n\t\t\t}.status"
+		   });
+		addAnnotation
+		  (relPatternEdgeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\tnot source.isExpression() implies\n\t\t\tsource.referredEClassifier.oclIsKindOf(ecore::EClassifier)"
+		   });
+		addAnnotation
+		  (relPatternEdgeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\tnot source.isExpression()"
+		   });
+		addAnnotation
+		  (relPatternEdgeEClass.getEOperations().get(2),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\treferredEStructuralFeature <> null and\n\t\t\treferredEStructuralFeature.oclIsKindOf(ecore::EAttribute) and\n\t\t\tnot target.isExpression() implies\n\t\t\treferredEStructuralFeature.eType = target.referredEClassifier"
+		   });
+		addAnnotation
+		  (relPatternEdgeEClass.getEOperations().get(3),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\t(referredEStructuralFeature = null) = source.isMany"
+		   });
+		addAnnotation
+		  (relPatternEdgeEClass.getEOperations().get(4),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\treferredEStructuralFeature <> null and\n\t\t\treferredEStructuralFeature.oclIsKindOf(ecore::EReference) and\n\t\t\tnot target.isExpression() implies\n\t\t\tlet sourceEClass = target.referredEClassifier.oclAsType(ecore::EClass) in\n\t\t\tsourceEClass->closure(eSuperTypes)->includes(referredEStructuralFeature.eType)"
+		   });
+		addAnnotation
+		  (relPatternEdgeEClass.getEOperations().get(5),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\treferredEStructuralFeature <> null implies\n\t\t\tsource.referredEClassifier.oclAsType(ecore::EClass)->closure(eSuperTypes)->includes(referredEStructuralFeature.eContainingClass)"
+		   });
+		addAnnotation
+		  (relPatternEdgeEClass.getEOperations().get(6),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\t(referredEStructuralFeature <> null) = (sourceIndex = 0)"
+		   });
+		addAnnotation
+		  (relPatternEdgeEClass.getEOperations().get(7),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\treferredEStructuralFeature = null and\n\t\t\tsourceIndex < 0 and\n\t\t\tnot target.isExpression() implies\n\t\t\tlet sourceEClass = source.referredEClassifier.oclAsType(ecore::EClass) in\n\t\t\tlet targetEClass = target.referredEClassifier.oclAsType(ecore::EClass) in\n\t\t\tsourceEClass = targetEClass and\n\t\t\tsource.isMany = target.isMany and\n\t\t\tsource.isNullFree = target.isNullFree and\n\t\t\tsource.isOrdered = target.isOrdered and\n\t\t\tsource.isUnique = target.isUnique"
+		   });
+		addAnnotation
+		  (relPatternEdgeEClass.getEOperations().get(8),
+		   source,
+		   new String[] {
+			   "body", "\n\t\t\treferredEStructuralFeature = null and\n\t\t\tsourceIndex > 0 and\n\t\t\tnot target.isExpression() implies\n\t\t\tlet sourceEClass = source.referredEClassifier.oclAsType(ecore::EClass) in\n\t\t\tlet targetEClass = target.referredEClassifier.oclAsType(ecore::EClass) in\n\t\t\tsourceEClass->closure(eSuperTypes)->includes(targetEClass) or targetEClass->closure(eSuperTypes)->includes(sourceEClass)"
+		   });
+		addAnnotation
+		  (relPatternNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "name = null and initExpressionLines->notEmpty()"
+		   });
+		addAnnotation
+		  (relPatternNodeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "body", "\n\t\tnot isExpression() implies\n\t\tisAnon = (name = \'\')"
+		   });
+		addAnnotation
+		  (relPatternNodeEClass.getEOperations().get(2),
+		   source,
+		   new String[] {
+			   "body", "\n\t\tnot isExpression() implies\n\t\treferredEClassifier <> null"
+		   });
+		addAnnotation
+		  (relPatternNodeEClass.getEOperations().get(3),
+		   source,
+		   new String[] {
+			   "body", "\n\t\tnot isExpression() implies\n\t\tlet txTypedModelNode = owningRelDomainNode.referredTxTypedModelNode in\n\t\ttxTypedModelNode <> null implies\n\t\ttxTypedModelNode.usedTxPackageNodes.referredEPackage.eClassifiers->includes(referredEClassifier)"
+		   });
+		addAnnotation
+		  (txDiagramEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "ownedTxQueryNodes->isUnique(name)"
+		   });
+		addAnnotation
+		  (txDiagramEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "body", "ownedRelDiagrams->isUnique(name)"
+		   });
+		addAnnotation
+		  (txDiagramEClass.getEOperations().get(2),
+		   source,
+		   new String[] {
+			   "body", "name <> null"
+		   });
+		addAnnotation
+		  (txDiagramEClass.getEOperations().get(3),
+		   source,
+		   new String[] {
+			   "body", "ownedTxTypedModelNodes->isUnique(name)"
+		   });
+		addAnnotation
+		  (txKeyNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "ownedTxPartNodes->isUnique(referredEStructuralFeature)"
+		   });
+		addAnnotation
+		  (txParameterNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "name <> null"
+		   });
+		addAnnotation
+		  (txParameterNodeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "body", "referredEClassifier <> null"
+		   });
+		addAnnotation
+		  (txPartNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "owningTxKeyNode.referredEClass.oclAsType(ecore::EClass)->closure(eSuperTypes)->includes(referredEStructuralFeature.eContainingClass)"
+		   });
+		addAnnotation
+		  (txQueryNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "name <> null"
+		   });
+		addAnnotation
+		  (txQueryNodeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "body", "referredEClassifier <> null"
+		   });
+		addAnnotation
+		  (txQueryNodeEClass.getEOperations().get(2),
+		   source,
+		   new String[] {
+			   "body", "ownedTxParameterNodes->isUnique(name)"
+		   });
+		addAnnotation
+		  (txTypedModelNodeEClass.getEOperations().get(0),
+		   source,
+		   new String[] {
+			   "body", "usedTxPackageNodes->isUnique(referredEPackage)"
+		   });
+		addAnnotation
+		  (txTypedModelNodeEClass.getEOperations().get(1),
+		   source,
+		   new String[] {
+			   "body", "name <> null"
+		   });
 	}
 
 } //UMLXPackageImpl
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXTypedElementImpl.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXTypedElementImpl.java
index 2041cdb..be15693 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXTypedElementImpl.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/impl/UMLXTypedElementImpl.java
@@ -41,6 +41,15 @@
  */
 public abstract class UMLXTypedElementImpl extends UMLXNamedElementImpl implements UMLXTypedElement {
 	/**
+	 * The number of structural features of the '<em>Typed Element</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	public static final int UMLX_TYPED_ELEMENT_FEATURE_COUNT = UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 6;
+
+	/**
 	 * The default value of the '{@link #isIsMany() <em>Is Many</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -189,7 +198,7 @@
 		boolean oldIsMany = isMany;
 		isMany = newIsMany;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY, oldIsMany, isMany));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0, oldIsMany, isMany));
 	}
 
 	/**
@@ -212,7 +221,7 @@
 		boolean oldIsNullFree = isNullFree;
 		isNullFree = newIsNullFree;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE, oldIsNullFree, isNullFree));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1, oldIsNullFree, isNullFree));
 	}
 
 	/**
@@ -235,7 +244,7 @@
 		boolean oldIsOrdered = isOrdered;
 		isOrdered = newIsOrdered;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED, oldIsOrdered, isOrdered));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2, oldIsOrdered, isOrdered));
 	}
 
 	/**
@@ -258,7 +267,7 @@
 		boolean oldIsRequired = isRequired;
 		isRequired = newIsRequired;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED, oldIsRequired, isRequired));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3, oldIsRequired, isRequired));
 	}
 
 	/**
@@ -281,7 +290,7 @@
 		boolean oldIsUnique = isUnique;
 		isUnique = newIsUnique;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE, oldIsUnique, isUnique));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4, oldIsUnique, isUnique));
 	}
 
 	/**
@@ -296,7 +305,7 @@
 			referredEClassifier = (EClassifier)eResolveProxy(oldReferredEClassifier);
 			if (referredEClassifier != oldReferredEClassifier) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER, oldReferredEClassifier, referredEClassifier));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5, oldReferredEClassifier, referredEClassifier));
 			}
 		}
 		return referredEClassifier;
@@ -321,7 +330,7 @@
 		EClassifier oldReferredEClassifier = referredEClassifier;
 		referredEClassifier = newReferredEClassifier;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER, oldReferredEClassifier, referredEClassifier));
+			eNotify(new ENotificationImpl(this, Notification.SET, UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5, oldReferredEClassifier, referredEClassifier));
 	}
 
 	/**
@@ -331,7 +340,21 @@
 	 */
 	@Override
 	public String toString() {
-		return super.toString();
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (isMany: ");
+		result.append(isMany);
+		result.append(", isNullFree: ");
+		result.append(isNullFree);
+		result.append(", isOrdered: ");
+		result.append(isOrdered);
+		result.append(", isRequired: ");
+		result.append(isRequired);
+		result.append(", isUnique: ");
+		result.append(isUnique);
+		result.append(')');
+		return result.toString();
 	}
 
 	/**
@@ -342,17 +365,17 @@
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				return isIsMany();
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				return isIsNullFree();
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return isIsOrdered();
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return isIsRequired();
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				return isIsUnique();
-			case UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5:
 				if (resolve) return getReferredEClassifier();
 				return basicGetReferredEClassifier();
 		}
@@ -367,22 +390,22 @@
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				setIsMany((Boolean)newValue);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				setIsNullFree((Boolean)newValue);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				setIsOrdered((Boolean)newValue);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				setIsRequired((Boolean)newValue);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				setIsUnique((Boolean)newValue);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5:
 				setReferredEClassifier((EClassifier)newValue);
 				return;
 		}
@@ -397,22 +420,22 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				setIsMany(IS_MANY_EDEFAULT);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				setIsNullFree(IS_NULL_FREE_EDEFAULT);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				setIsOrdered(IS_ORDERED_EDEFAULT);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				setIsRequired(IS_REQUIRED_EDEFAULT);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				setIsUnique(IS_UNIQUE_EDEFAULT);
 				return;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5:
 				setReferredEClassifier((EClassifier)null);
 				return;
 		}
@@ -427,17 +450,17 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_MANY:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 0:
 				return isMany != IS_MANY_EDEFAULT;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_NULL_FREE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 1:
 				return isNullFree != IS_NULL_FREE_EDEFAULT;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_ORDERED:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 2:
 				return isOrdered != IS_ORDERED_EDEFAULT;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_REQUIRED:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 3:
 				return isRequired != IS_REQUIRED_EDEFAULT;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__IS_UNIQUE:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 4:
 				return isUnique != IS_UNIQUE_EDEFAULT;
-			case UMLXPackage.UMLX_TYPED_ELEMENT__REFERRED_ECLASSIFIER:
+			case UMLXNamedElementImpl.UMLX_NAMED_ELEMENT_FEATURE_COUNT + 5:
 				return referredEClassifier != null;
 		}
 		return super.eIsSet(featureID);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/AbstractExtendingUMLXVisitor.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/AbstractExtendingUMLXVisitor.java
index 9f38a6a..a9af4f3 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/AbstractExtendingUMLXVisitor.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/AbstractExtendingUMLXVisitor.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2016, 2018 Willink Transformations and others.
+ * Copyright (c) 2016, 2019 Willink Transformations and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/AbstractUMLXVisitor.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/AbstractUMLXVisitor.java
index 1ce3243..2adcdbe 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/AbstractUMLXVisitor.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/AbstractUMLXVisitor.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2016, 2018 Willink Transformations and others.
+ * Copyright (c) 2016, 2019 Willink Transformations and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXSwitch.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXSwitch.java
index 91204c9..972abca 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXSwitch.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXSwitch.java
@@ -74,7 +74,7 @@
 	@Override
 	protected T doSwitch(int classifierID, EObject theEObject) {
 		switch (classifierID) {
-			case UMLXPackage.REL_DIAGRAM: {
+			case 0: {
 				RelDiagram relDiagram = (RelDiagram)theEObject;
 				T result = caseRelDiagram(relDiagram);
 				if (result == null) result = caseUMLXNamedElement(relDiagram);
@@ -82,7 +82,7 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.REL_DOMAIN_NODE: {
+			case 1: {
 				RelDomainNode relDomainNode = (RelDomainNode)theEObject;
 				T result = caseRelDomainNode(relDomainNode);
 				if (result == null) result = caseRelNode(relDomainNode);
@@ -90,14 +90,14 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.REL_EDGE: {
+			case 2: {
 				RelEdge relEdge = (RelEdge)theEObject;
 				T result = caseRelEdge(relEdge);
 				if (result == null) result = caseUMLXElement(relEdge);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.REL_INVOCATION_EDGE: {
+			case 3: {
 				RelInvocationEdge relInvocationEdge = (RelInvocationEdge)theEObject;
 				T result = caseRelInvocationEdge(relInvocationEdge);
 				if (result == null) result = caseRelEdge(relInvocationEdge);
@@ -105,7 +105,7 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.REL_INVOCATION_NODE: {
+			case 4: {
 				RelInvocationNode relInvocationNode = (RelInvocationNode)theEObject;
 				T result = caseRelInvocationNode(relInvocationNode);
 				if (result == null) result = caseRelNode(relInvocationNode);
@@ -113,14 +113,14 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.REL_NODE: {
+			case 5: {
 				RelNode relNode = (RelNode)theEObject;
 				T result = caseRelNode(relNode);
 				if (result == null) result = caseUMLXElement(relNode);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.REL_PATTERN_EDGE: {
+			case 6: {
 				RelPatternEdge relPatternEdge = (RelPatternEdge)theEObject;
 				T result = caseRelPatternEdge(relPatternEdge);
 				if (result == null) result = caseRelEdge(relPatternEdge);
@@ -128,7 +128,7 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.REL_PATTERN_NODE: {
+			case 7: {
 				RelPatternNode relPatternNode = (RelPatternNode)theEObject;
 				T result = caseRelPatternNode(relPatternNode);
 				if (result == null) result = caseRelNode(relPatternNode);
@@ -138,7 +138,7 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.TX_DIAGRAM: {
+			case 8: {
 				TxDiagram txDiagram = (TxDiagram)theEObject;
 				T result = caseTxDiagram(txDiagram);
 				if (result == null) result = caseUMLXNamedElement(txDiagram);
@@ -146,7 +146,7 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.TX_KEY_NODE: {
+			case 9: {
 				TxKeyNode txKeyNode = (TxKeyNode)theEObject;
 				T result = caseTxKeyNode(txKeyNode);
 				if (result == null) result = caseTxNode(txKeyNode);
@@ -154,14 +154,14 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.TX_NODE: {
+			case 10: {
 				TxNode txNode = (TxNode)theEObject;
 				T result = caseTxNode(txNode);
 				if (result == null) result = caseUMLXElement(txNode);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.TX_PACKAGE_NODE: {
+			case 11: {
 				TxPackageNode txPackageNode = (TxPackageNode)theEObject;
 				T result = caseTxPackageNode(txPackageNode);
 				if (result == null) result = caseTxNode(txPackageNode);
@@ -169,7 +169,7 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.TX_PARAMETER_NODE: {
+			case 12: {
 				TxParameterNode txParameterNode = (TxParameterNode)theEObject;
 				T result = caseTxParameterNode(txParameterNode);
 				if (result == null) result = caseTxNode(txParameterNode);
@@ -179,7 +179,7 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.TX_PART_NODE: {
+			case 13: {
 				TxPartNode txPartNode = (TxPartNode)theEObject;
 				T result = caseTxPartNode(txPartNode);
 				if (result == null) result = caseTxNode(txPartNode);
@@ -187,7 +187,7 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.TX_QUERY_NODE: {
+			case 14: {
 				TxQueryNode txQueryNode = (TxQueryNode)theEObject;
 				T result = caseTxQueryNode(txQueryNode);
 				if (result == null) result = caseTxNode(txQueryNode);
@@ -197,7 +197,7 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.TX_TYPED_MODEL_NODE: {
+			case 15: {
 				TxTypedModelNode txTypedModelNode = (TxTypedModelNode)theEObject;
 				T result = caseTxTypedModelNode(txTypedModelNode);
 				if (result == null) result = caseTxNode(txTypedModelNode);
@@ -206,27 +206,27 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.UMLX_ELEMENT: {
+			case 16: {
 				UMLXElement umlxElement = (UMLXElement)theEObject;
 				T result = caseUMLXElement(umlxElement);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.UMLX_MODEL: {
+			case 17: {
 				UMLXModel umlxModel = (UMLXModel)theEObject;
 				T result = caseUMLXModel(umlxModel);
 				if (result == null) result = caseUMLXElement(umlxModel);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.UMLX_NAMED_ELEMENT: {
+			case 18: {
 				UMLXNamedElement umlxNamedElement = (UMLXNamedElement)theEObject;
 				T result = caseUMLXNamedElement(umlxNamedElement);
 				if (result == null) result = caseUMLXElement(umlxNamedElement);
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
-			case UMLXPackage.UMLX_TYPED_ELEMENT: {
+			case 19: {
 				UMLXTypedElement umlxTypedElement = (UMLXTypedElement)theEObject;
 				T result = caseUMLXTypedElement(umlxTypedElement);
 				if (result == null) result = caseUMLXNamedElement(umlxTypedElement);
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXValidator.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXValidator.java
index 620afcc..a184ebb 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXValidator.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXValidator.java
@@ -317,45 +317,45 @@
 	@Override
 	protected boolean validate(int classifierID, Object value, DiagnosticChain diagnostics, Map<Object, Object> context) {
 		switch (classifierID) {
-			case UMLXPackage.REL_DIAGRAM:
+			case 0:
 				return validateRelDiagram((RelDiagram)value, diagnostics, context);
-			case UMLXPackage.REL_DOMAIN_NODE:
+			case 1:
 				return validateRelDomainNode((RelDomainNode)value, diagnostics, context);
-			case UMLXPackage.REL_EDGE:
+			case 2:
 				return validateRelEdge((RelEdge)value, diagnostics, context);
-			case UMLXPackage.REL_INVOCATION_EDGE:
+			case 3:
 				return validateRelInvocationEdge((RelInvocationEdge)value, diagnostics, context);
-			case UMLXPackage.REL_INVOCATION_NODE:
+			case 4:
 				return validateRelInvocationNode((RelInvocationNode)value, diagnostics, context);
-			case UMLXPackage.REL_NODE:
+			case 5:
 				return validateRelNode((RelNode)value, diagnostics, context);
-			case UMLXPackage.REL_PATTERN_EDGE:
+			case 6:
 				return validateRelPatternEdge((RelPatternEdge)value, diagnostics, context);
-			case UMLXPackage.REL_PATTERN_NODE:
+			case 7:
 				return validateRelPatternNode((RelPatternNode)value, diagnostics, context);
-			case UMLXPackage.TX_DIAGRAM:
+			case 8:
 				return validateTxDiagram((TxDiagram)value, diagnostics, context);
-			case UMLXPackage.TX_KEY_NODE:
+			case 9:
 				return validateTxKeyNode((TxKeyNode)value, diagnostics, context);
-			case UMLXPackage.TX_NODE:
+			case 10:
 				return validateTxNode((TxNode)value, diagnostics, context);
-			case UMLXPackage.TX_PACKAGE_NODE:
+			case 11:
 				return validateTxPackageNode((TxPackageNode)value, diagnostics, context);
-			case UMLXPackage.TX_PARAMETER_NODE:
+			case 12:
 				return validateTxParameterNode((TxParameterNode)value, diagnostics, context);
-			case UMLXPackage.TX_PART_NODE:
+			case 13:
 				return validateTxPartNode((TxPartNode)value, diagnostics, context);
-			case UMLXPackage.TX_QUERY_NODE:
+			case 14:
 				return validateTxQueryNode((TxQueryNode)value, diagnostics, context);
-			case UMLXPackage.TX_TYPED_MODEL_NODE:
+			case 15:
 				return validateTxTypedModelNode((TxTypedModelNode)value, diagnostics, context);
-			case UMLXPackage.UMLX_ELEMENT:
+			case 16:
 				return validateUMLXElement((UMLXElement)value, diagnostics, context);
-			case UMLXPackage.UMLX_MODEL:
+			case 17:
 				return validateUMLXModel((UMLXModel)value, diagnostics, context);
-			case UMLXPackage.UMLX_NAMED_ELEMENT:
+			case 18:
 				return validateUMLXNamedElement((UMLXNamedElement)value, diagnostics, context);
-			case UMLXPackage.UMLX_TYPED_ELEMENT:
+			case 19:
 				return validateUMLXTypedElement((UMLXTypedElement)value, diagnostics, context);
 			default:
 				return true;
diff --git a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXVisitor.java b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXVisitor.java
index abda5a6..4f57fce 100644
--- a/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXVisitor.java
+++ b/plugins/org.eclipse.qvtd.umlx/emf-gen/org/eclipse/qvtd/umlx/util/UMLXVisitor.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2016, 2018 Willink Transformations and others.
+ * Copyright (c) 2016, 2019 Willink Transformations and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
diff --git a/plugins/org.eclipse.qvtd.umlx/model/UMLX.genmodel b/plugins/org.eclipse.qvtd.umlx/model/UMLX.genmodel
index b849061..39ec131 100644
--- a/plugins/org.eclipse.qvtd.umlx/model/UMLX.genmodel
+++ b/plugins/org.eclipse.qvtd.umlx/model/UMLX.genmodel
@@ -1,9 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="Copyright (c) 2016 Willink Transformations and others.&#xD;&#xA;All rights reserved. This program and the accompanying materials&#xD;&#xA;are made available under the terms of the Eclipse Public License v2.0&#xD;&#xA;which accompanies this distribution, and is available at&#xD;&#xA;http://www.eclipse.org/legal/epl-v20.html&#xD;&#xA;&#xD;&#xA;Contributors:&#xD;&#xA;  E.D.Willink - Initial API and implementation"
+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="Copyright (c) 2016, 2019 Willink Transformations and others.&#xA;All rights reserved. This program and the accompanying materials&#xA;are made available under the terms of the Eclipse Public License v2.0&#xA;which accompanies this distribution, and is available at&#xA;http://www.eclipse.org/legal/epl-v20.html&#xA;&#xA;Contributors:&#xA;  E.D.Willink - Initial API and implementation"
     modelDirectory="/org.eclipse.qvtd.umlx/emf-gen" editDirectory="/org.eclipse.qvtd.umlx.edit/emf-gen"
     editorDirectory="/org.eclipse.qvtd.umlx.editor/emf-gen" modelPluginID="org.eclipse.qvtd.umlx"
-    modelName="UMLX" updateClasspath="false" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
+    templateDirectory="/org.eclipse.ocl.examples.codegen/templates" modelName="UMLX"
+    updateClasspath="false" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
     suppressEMFModelTags="true" testsDirectory="/org.eclipse.qvtd.umlx.tests/emf-gen"
     importerID="org.eclipse.emf.importer.ecore" bundleManifest="false" complianceLevel="8.0"
     copyrightFields="false" runtimeVersion="2.7" importOrganizing="true" pluginKey="">
diff --git a/releng/org.eclipse.qvtd.build/src/org/eclipse/qvtd/build/mwe2/GenerateQVTdUMLXModels.mwe2 b/releng/org.eclipse.qvtd.build/src/org/eclipse/qvtd/build/mwe2/GenerateQVTdUMLXModels.mwe2
index 70c8892..1e692a1 100644
--- a/releng/org.eclipse.qvtd.build/src/org/eclipse/qvtd/build/mwe2/GenerateQVTdUMLXModels.mwe2
+++ b/releng/org.eclipse.qvtd.build/src/org/eclipse/qvtd/build/mwe2/GenerateQVTdUMLXModels.mwe2
@@ -26,6 +26,7 @@
  */
 Workflow {
 	bean = ResourceSetImpl : umlxResourceSet {}
+    bean = ProjectMapSetup { resourceSet = umlxResourceSet }
     bean = StandaloneSetup { resourceSet = umlxResourceSet
     	platformUri = ".."
     	scanClassPath = true
