diff --git a/features/org.eclipse.papyrus.model2doc.feature/feature.xml b/features/org.eclipse.papyrus.model2doc.feature/feature.xml
index 219e230..7a16a9b 100755
--- a/features/org.eclipse.papyrus.model2doc.feature/feature.xml
+++ b/features/org.eclipse.papyrus.model2doc.feature/feature.xml
@@ -111,6 +111,20 @@
          unpack="false"/>
 
    <plugin
+         id="org.eclipse.papyrus.model2doc.core.styles"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.papyrus.model2doc.core.styles.edit"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
          id="org.eclipse.papyrus.model2doc.documentview.model"
          download-size="0"
          install-size="0"
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/META-INF/MANIFEST.MF b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/META-INF/MANIFEST.MF
index 6be62f4..dc9666c 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/META-INF/MANIFEST.MF
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/META-INF/MANIFEST.MF
@@ -10,8 +10,10 @@
 Bundle-Localization: plugin
 Bundle-RequiredExecutionEnvironment: JavaSE-11
 Export-Package: org.eclipse.papyrus.model2doc.core.builtintypes.provider
-Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.15.0,4.0.0)";x-installation:=greedy;resolution:=optional,
+Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.15.0,4.0.0)";resolution:=optional;x-installation:=greedy,
  org.eclipse.papyrus.model2doc.core.builtintypes;bundle-version="[0.7.0,1.0.0)",
- org.eclipse.emf.edit;bundle-version="[2.14.0,3.0.0)"
+ org.eclipse.emf.edit;bundle-version="[2.14.0,3.0.0)",
+ org.eclipse.papyrus.model2doc.core.styles;bundle-version="[0.8.0,1.0.0)",
+ org.eclipse.papyrus.model2doc.core.styles.edit;bundle-version="[0.8.0,1.0.0)"
 Import-Package: org.osgi.framework
 Bundle-ActivationPolicy: lazy
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/provider/BuiltInTypesEditPlugin.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/provider/BuiltInTypesEditPlugin.java
index d02200f..b9ea642 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/provider/BuiltInTypesEditPlugin.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/provider/BuiltInTypesEditPlugin.java
@@ -17,6 +17,7 @@
 
 import org.eclipse.emf.common.util.ResourceLocator;
 
+import org.eclipse.papyrus.model2doc.core.styles.provider.StylesEditPlugin;
 import org.osgi.framework.BundleActivator;
 
 /**
@@ -54,6 +55,7 @@
 	 */
 	public BuiltInTypesEditPlugin() {
 		super(new ResourceLocator[] {
+				StylesEditPlugin.INSTANCE,
 		});
 	}
 
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/provider/TextCellItemProvider.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/provider/TextCellItemProvider.java
index 6d57ccf..0f1ea66 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/provider/TextCellItemProvider.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes.edit/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/provider/TextCellItemProvider.java
@@ -22,6 +22,7 @@
 
 import org.eclipse.emf.common.util.ResourceLocator;
 
+import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
 import org.eclipse.emf.edit.provider.IChildCreationExtender;
 import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
@@ -36,6 +37,8 @@
 
 import org.eclipse.papyrus.model2doc.core.builtintypes.BuiltInTypesPackage;
 import org.eclipse.papyrus.model2doc.core.builtintypes.TextCell;
+import org.eclipse.papyrus.model2doc.core.styles.StylesFactory;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
 
 /**
  * This is the item provider adapter for a {@link org.eclipse.papyrus.model2doc.core.builtintypes.TextCell} object.
@@ -124,6 +127,38 @@
 	}
 
 	/**
+	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
+	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
+	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object) {
+		if (childrenFeatures == null) {
+			super.getChildrenFeatures(object);
+			childrenFeatures.add(StylesPackage.Literals.STYLED_ELEMENT__NAMED_STYLES);
+		}
+		return childrenFeatures;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected EStructuralFeature getChildFeature(Object object, Object child) {
+		// Check the type of the specified child object and return the proper feature to use for
+		// adding (see {@link AddCommand}) it as a child.
+
+		return super.getChildFeature(object, child);
+	}
+
+	/**
 	 * This returns TextCell.gif.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -178,6 +213,9 @@
 		case BuiltInTypesPackage.TEXT_CELL__TEXT:
 			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
 			return;
+		case BuiltInTypesPackage.TEXT_CELL__NAMED_STYLES:
+			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
+			return;
 		}
 		super.notifyChanged(notification);
 	}
@@ -193,6 +231,30 @@
 	@Override
 	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
 		super.collectNewChildDescriptors(newChildDescriptors, object);
+
+		newChildDescriptors.add(createChildParameter(StylesPackage.Literals.STYLED_ELEMENT__NAMED_STYLES,
+				StylesFactory.eINSTANCE.createIntNamedStyle()));
+
+		newChildDescriptors.add(createChildParameter(StylesPackage.Literals.STYLED_ELEMENT__NAMED_STYLES,
+				StylesFactory.eINSTANCE.createStringNamedStyle()));
+
+		newChildDescriptors.add(createChildParameter(StylesPackage.Literals.STYLED_ELEMENT__NAMED_STYLES,
+				StylesFactory.eINSTANCE.createBooleanNamedStyle()));
+
+		newChildDescriptors.add(createChildParameter(StylesPackage.Literals.STYLED_ELEMENT__NAMED_STYLES,
+				StylesFactory.eINSTANCE.createDoubleNamedStyle()));
+
+		newChildDescriptors.add(createChildParameter(StylesPackage.Literals.STYLED_ELEMENT__NAMED_STYLES,
+				StylesFactory.eINSTANCE.createIntListNamedStyle()));
+
+		newChildDescriptors.add(createChildParameter(StylesPackage.Literals.STYLED_ELEMENT__NAMED_STYLES,
+				StylesFactory.eINSTANCE.createStringListNamedStyle()));
+
+		newChildDescriptors.add(createChildParameter(StylesPackage.Literals.STYLED_ELEMENT__NAMED_STYLES,
+				StylesFactory.eINSTANCE.createBooleanListNamedStyle()));
+
+		newChildDescriptors.add(createChildParameter(StylesPackage.Literals.STYLED_ELEMENT__NAMED_STYLES,
+				StylesFactory.eINSTANCE.createDoubleListNamedStyle()));
 	}
 
 	/**
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/META-INF/MANIFEST.MF b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/META-INF/MANIFEST.MF
index a22a4e2..e1edb74 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/META-INF/MANIFEST.MF
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/META-INF/MANIFEST.MF
@@ -11,6 +11,7 @@
 Export-Package: org.eclipse.papyrus.model2doc.core.builtintypes,
  org.eclipse.papyrus.model2doc.core.builtintypes.impl,
  org.eclipse.papyrus.model2doc.core.builtintypes.util
-Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.15.0,4.0.0)";x-installation:=greedy,
- org.eclipse.emf.ecore;bundle-version="[2.17.0,3.0.0)"
+Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.15.0,4.0.0)";resolution:=optional;x-installation:=greedy,
+ org.eclipse.emf.ecore;bundle-version="[2.17.0,3.0.0)",
+ org.eclipse.papyrus.model2doc.core.styles;bundle-version="[0.8.0,1.0.0)"
 Bundle-ActivationPolicy: lazy
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.ecore b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.ecore
index 368557e..ae8474c 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.ecore
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.ecore
@@ -51,7 +51,8 @@
       </eAnnotations>
     </eStructuralFeatures>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Cell" abstract="true" interface="true">
+  <eClassifiers xsi:type="ecore:EClass" name="Cell" abstract="true" interface="true"
+      eSuperTypes="../../org.eclipse.papyrus.model2doc.core.styles/model/Styles.ecore#//StyledElement">
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="location" ordered="false"
         lowerBound="1" eType="#//CellLocation" defaultValueLiteral="BODY">
       <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.genmodel b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.genmodel
index 7a711ee..08ec4e6 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.genmodel
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.genmodel
@@ -9,6 +9,7 @@
     nonNLSMarkers="true" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
     codeFormatting="true" commentFormatting="true" testsDirectory="/org.eclipse.papyrus.model2doc.core.builtintypes.tests/src-gen"
     importerID="org.eclipse.uml2.uml.ecore.importer" complianceLevel="8.0" copyrightFields="false"
+    usedGenPackages="../../org.eclipse.papyrus.model2doc.core.styles/model/Styles.genmodel#//styles"
     operationReflection="true" importOrganizing="true" cleanup="true" oSGiCompatible="true"
     pluralizedGetters="true">
   <genAnnotations source="http://www.eclipse.org/emf/2002/GenModel/importer/org.eclipse.uml2.uml.ecore.importer">
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.notation b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.notation
index ff9fde0..a22e227 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.notation
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.notation
@@ -179,7 +179,7 @@
         <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H_h6yXALEemJ-foOn68QUw"/>
       </children>
       <element xmi:type="uml:Enumeration" href="BuiltInTypes.uml#_H_dCQHALEemJ-foOn68QUw"/>
-      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H_h6wXALEemJ-foOn68QUw" x="-120" y="280"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_H_h6wXALEemJ-foOn68QUw" x="-120" y="240"/>
     </children>
     <children xmi:type="notation:Shape" xmi:id="_XySo4HALEemJ-foOn68QUw" type="Class_Shape" fontName="Segoe UI" fillColor="14538691" transparency="0" gradient="16777215, -1, 0" lineColor="0">
       <children xmi:type="notation:DecorationNode" xmi:id="_XyTP8HALEemJ-foOn68QUw" type="Class_NameLabel"/>
@@ -383,6 +383,32 @@
       <element xmi:type="uml:Class" href="BuiltInTypes.uml#_tL-NYJQUEemHKPZQudxUGA"/>
       <layoutConstraint xmi:type="notation:Bounds" xmi:id="_tMGwQZQUEemHKPZQudxUGA" x="40" y="980" width="201"/>
     </children>
+    <children xmi:type="notation:Shape" xmi:id="_hLCBoC8ZEeuTioAhh-QJ3Q" type="Interface_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_hLG6IC8ZEeuTioAhh-QJ3Q" type="Interface_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_hLG6IS8ZEeuTioAhh-QJ3Q" type="Interface_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_hLG6Ii8ZEeuTioAhh-QJ3Q" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hLHhMC8ZEeuTioAhh-QJ3Q" type="Interface_AttributeCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hLHhMS8ZEeuTioAhh-QJ3Q"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hLHhMi8ZEeuTioAhh-QJ3Q"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hLHhMy8ZEeuTioAhh-QJ3Q"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hLHhNC8ZEeuTioAhh-QJ3Q"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hLHhNS8ZEeuTioAhh-QJ3Q" type="Interface_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hLHhNi8ZEeuTioAhh-QJ3Q"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hLHhNy8ZEeuTioAhh-QJ3Q"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hLHhOC8ZEeuTioAhh-QJ3Q"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hLHhOS8ZEeuTioAhh-QJ3Q"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hLHhOi8ZEeuTioAhh-QJ3Q" type="Interface_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hLHhOy8ZEeuTioAhh-QJ3Q"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hLHhPC8ZEeuTioAhh-QJ3Q"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hLHhPS8ZEeuTioAhh-QJ3Q"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hLHhPi8ZEeuTioAhh-QJ3Q"/>
+      </children>
+      <element xmi:type="uml:Interface" href="pathmap://MODEL2DOC/STYLES/Styles.uml#_cPAPwC5ZEeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hLCBoS8ZEeuTioAhh-QJ3Q" x="-160" y="380" width="121" height="121"/>
+    </children>
     <styles xmi:type="notation:StringValueStyle" xmi:id="_WXAMEXAKEemJ-foOn68QUw" name="diagram_compatibility_version" stringValue="1.4.0"/>
     <styles xmi:type="notation:DiagramStyle" xmi:id="_WXAMEnAKEemJ-foOn68QUw"/>
     <styles xmi:type="style:PapyrusDiagramStyle" xmi:id="_WXAME3AKEemJ-foOn68QUw" diagramKindId="org.eclipse.papyrus.uml.diagram.class">
@@ -584,6 +610,17 @@
       <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_AM784JQVEemHKPZQudxUGA" id="(0.4975124378109453,0.0)"/>
       <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_AM784ZQVEemHKPZQudxUGA" id="(0.4975124378109453,1.0)"/>
     </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_lFg6MC8ZEeuTioAhh-QJ3Q" type="Generalization_Edge" source="_EUWCcHALEemJ-foOn68QUw" target="_hLCBoC8ZEeuTioAhh-QJ3Q" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_lFhhQC8ZEeuTioAhh-QJ3Q" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_modToC8ZEeuTioAhh-QJ3Q" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_lFiIUC8ZEeuTioAhh-QJ3Q" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_lFg6MS8ZEeuTioAhh-QJ3Q" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="BuiltInTypes.uml#_lEiCwC8ZEeuTioAhh-QJ3Q"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_lFg6Mi8ZEeuTioAhh-QJ3Q" points="[40, 440, -643984, -643984]$[-13, 440, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_lHSb0C8ZEeuTioAhh-QJ3Q" id="(0.0,0.5405405405405406)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_lHTC4C8ZEeuTioAhh-QJ3Q" id="(1.0,0.49586776859504134)"/>
+    </edges>
   </notation:Diagram>
   <css:ModelStyleSheets xmi:id="_ePy4kHCfEemJ-foOn68QUw">
     <stylesheets xmi:type="css:StyleSheetReference" xmi:id="_eP0GsHCfEemJ-foOn68QUw" path="/org.eclipse.papyrus.model2doc.core.builtintypes/model/custom.css"/>
@@ -611,7 +648,7 @@
       <element xmi:type="uml:Enumeration" href="BuiltInTypes.uml#_I9QFkBn9EeunG-PlCrg2Pg"/>
       <layoutConstraint xmi:type="notation:Bounds" xmi:id="_I9bEsRn9EeunG-PlCrg2Pg" x="140" y="100"/>
     </children>
-    <children xmi:type="notation:Shape" xmi:id="_ulewEB9sEeufppQNI_9Idw" type="Comment_Shape">
+    <children xmi:type="notation:Shape" xmi:id="_ulewEB9sEeufppQNI_9Idw" type="Comment_Shape" fontName="Segoe UI" fillColor="13434879" transparency="0" gradient="16777215, -1, 0" lineColor="0">
       <children xmi:type="notation:DecorationNode" xmi:id="_ulhzYB9sEeufppQNI_9Idw" type="Comment_BodyLabel"/>
       <element xmi:type="uml:Comment" href="BuiltInTypes.uml#_sHK6kB9sEeufppQNI_9Idw"/>
       <layoutConstraint xmi:type="notation:Bounds" xmi:id="_ulewER9sEeufppQNI_9Idw" x="320" y="120"/>
@@ -622,8 +659,8 @@
       <owner xmi:type="uml:Model" href="BuiltInTypes.uml#_WW0l4HAKEemJ-foOn68QUw"/>
     </styles>
     <element xmi:type="uml:Model" href="BuiltInTypes.uml#_WW0l4HAKEemJ-foOn68QUw"/>
-    <edges xmi:type="notation:Connector" xmi:id="_v--SkB9sEeufppQNI_9Idw" type="Comment_AnnotatedElementEdge" source="_ulewEB9sEeufppQNI_9Idw" target="_I9bEsBn9EeunG-PlCrg2Pg">
-      <styles xmi:type="notation:FontStyle" xmi:id="_v--5oB9sEeufppQNI_9Idw"/>
+    <edges xmi:type="notation:Connector" xmi:id="_v--SkB9sEeufppQNI_9Idw" type="Comment_AnnotatedElementEdge" source="_ulewEB9sEeufppQNI_9Idw" target="_I9bEsBn9EeunG-PlCrg2Pg" lineColor="0">
+      <styles xmi:type="notation:FontStyle" xmi:id="_v--5oB9sEeufppQNI_9Idw" fontName="Segoe UI"/>
       <element xsi:nil="true"/>
       <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_v--5oR9sEeufppQNI_9Idw" points="[360, 180, -643984, -643984]$[243, 160, -643984, -643984]"/>
       <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_v_czsB9sEeufppQNI_9Idw" id="(0.0,0.6666666666666666)"/>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.uml b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.uml
index 4f8cb67..97fbbdb 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.uml
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.uml
@@ -7,6 +7,9 @@
     <packageImport xmi:type="uml:PackageImport" xmi:id="_WaIYkHAKEemJ-foOn68QUw">
       <importedPackage xmi:type="uml:Model" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#_0"/>
     </packageImport>
+    <packageImport xmi:type="uml:PackageImport" xmi:id="_fmeeoC8ZEeuTioAhh-QJ3Q">
+      <importedPackage xmi:type="uml:Model" href="pathmap://MODEL2DOC/STYLES/Styles.uml#_tASnMC5PEeud9Ihhf94UEg"/>
+    </packageImport>
     <packagedElement xmi:type="uml:Class" xmi:id="_lYIB4HAKEemJ-foOn68QUw" name="AbstractTable" isAbstract="true">
       <ownedComment xmi:type="uml:Comment" xmi:id="_8e9l4HCfEemJ-foOn68QUw" annotatedElement="_lYIB4HAKEemJ-foOn68QUw">
         <body>Abstract class used to represent a Table in the Model2Doc API.</body>
@@ -84,6 +87,9 @@
       <interfaceRealization xmi:type="uml:InterfaceRealization" xmi:id="_C7ojEHALEemJ-foOn68QUw" client="__NYvsHAKEemJ-foOn68QUw" supplier="_-Rcr4HAKEemJ-foOn68QUw" contract="_-Rcr4HAKEemJ-foOn68QUw"/>
     </packagedElement>
     <packagedElement xmi:type="uml:Interface" xmi:id="_EUUNQHALEemJ-foOn68QUw" name="Cell">
+      <generalization xmi:type="uml:Generalization" xmi:id="_lEiCwC8ZEeuTioAhh-QJ3Q">
+        <general xmi:type="uml:Interface" href="pathmap://MODEL2DOC/STYLES/Styles.uml#_cPAPwC5ZEeud9Ihhf94UEg"/>
+      </generalization>
       <ownedAttribute xmi:type="uml:Property" xmi:id="_RDZH8HALEemJ-foOn68QUw" name="location" type="_H_dCQHALEemJ-foOn68QUw">
         <ownedComment xmi:type="uml:Comment" xmi:id="_f1hq0HCgEemJ-foOn68QUw" annotatedElement="_RDZH8HALEemJ-foOn68QUw">
           <body>The location of the cells.</body>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/AbstractTable.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/AbstractTable.java
index 314d814..efc4f90 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/AbstractTable.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/AbstractTable.java
@@ -61,7 +61,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param value
-	 *            the new value of the '<em>Caption</em>' attribute.
+	 *                  the new value of the '<em>Caption</em>' attribute.
 	 * @see #getCaption()
 	 * @generated
 	 */
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/BuiltInTypesPackage.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/BuiltInTypesPackage.java
index d23b17d..9f45006 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/BuiltInTypesPackage.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/BuiltInTypesPackage.java
@@ -19,6 +19,7 @@
 import org.eclipse.emf.ecore.EOperation;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
 
 /**
  * <!-- begin-user-doc -->
@@ -212,6 +213,16 @@
 	int CELL = 2;
 
 	/**
+	 * The feature id for the '<em><b>Named Styles</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int CELL__NAMED_STYLES = StylesPackage.STYLED_ELEMENT__NAMED_STYLES;
+
+	/**
 	 * The feature id for the '<em><b>Location</b></em>' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -219,7 +230,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	int CELL__LOCATION = 0;
+	int CELL__LOCATION = StylesPackage.STYLED_ELEMENT_FEATURE_COUNT + 0;
 
 	/**
 	 * The number of structural features of the '<em>Cell</em>' class.
@@ -229,7 +240,17 @@
 	 * @generated
 	 * @ordered
 	 */
-	int CELL_FEATURE_COUNT = 1;
+	int CELL_FEATURE_COUNT = StylesPackage.STYLED_ELEMENT_FEATURE_COUNT + 1;
+
+	/**
+	 * The operation id for the '<em>Get Named Style</em>' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int CELL___GET_NAMED_STYLE__STRING = StylesPackage.STYLED_ELEMENT___GET_NAMED_STYLE__STRING;
 
 	/**
 	 * The number of operations of the '<em>Cell</em>' class.
@@ -239,7 +260,7 @@
 	 * @generated
 	 * @ordered
 	 */
-	int CELL_OPERATION_COUNT = 0;
+	int CELL_OPERATION_COUNT = StylesPackage.STYLED_ELEMENT_OPERATION_COUNT + 0;
 
 	/**
 	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.builtintypes.impl.BasicTableImpl <em>Basic Table</em>}' class.
@@ -375,6 +396,16 @@
 	int TEXT_CELL = 5;
 
 	/**
+	 * The feature id for the '<em><b>Named Styles</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int TEXT_CELL__NAMED_STYLES = CELL__NAMED_STYLES;
+
+	/**
 	 * The feature id for the '<em><b>Location</b></em>' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -405,6 +436,16 @@
 	int TEXT_CELL_FEATURE_COUNT = CELL_FEATURE_COUNT + 1;
 
 	/**
+	 * The operation id for the '<em>Get Named Style</em>' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int TEXT_CELL___GET_NAMED_STYLE__STRING = CELL___GET_NAMED_STYLE__STRING;
+
+	/**
 	 * The number of operations of the '<em>Text Cell</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/Cell.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/Cell.java
index 308706a..9cd0575 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/Cell.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/Cell.java
@@ -13,7 +13,7 @@
  */
 package org.eclipse.papyrus.model2doc.core.builtintypes;
 
-import org.eclipse.emf.ecore.EObject;
+import org.eclipse.papyrus.model2doc.core.styles.StyledElement;
 
 /**
  * <!-- begin-user-doc -->
@@ -31,7 +31,7 @@
  * @model interface="true" abstract="true"
  * @generated
  */
-public interface Cell extends EObject {
+public interface Cell extends StyledElement {
 	/**
 	 * Returns the value of the '<em><b>Location</b></em>' attribute.
 	 * The default value is <code>"BODY"</code>.
@@ -57,7 +57,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param value
-	 *            the new value of the '<em>Location</em>' attribute.
+	 *                  the new value of the '<em>Location</em>' attribute.
 	 * @see org.eclipse.papyrus.model2doc.core.builtintypes.CellLocation
 	 * @see #getLocation()
 	 * @generated
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/CellLocation.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/CellLocation.java
index 8e728b2..b476b66 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/CellLocation.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/CellLocation.java
@@ -154,7 +154,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param literal
-	 *            the literal.
+	 *                    the literal.
 	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
@@ -174,7 +174,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param name
-	 *            the name.
+	 *                 the name.
 	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
@@ -194,7 +194,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param value
-	 *            the integer value.
+	 *                  the integer value.
 	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/DefaultFileReference.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/DefaultFileReference.java
index 03be064..a028778 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/DefaultFileReference.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/DefaultFileReference.java
@@ -58,7 +58,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param value
-	 *            the new value of the '<em>File Path</em>' attribute.
+	 *                  the new value of the '<em>File Path</em>' attribute.
 	 * @see #getFilePath()
 	 * @generated
 	 */
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/ImageFormat.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/ImageFormat.java
index 6bfb0db..1c44302 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/ImageFormat.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/ImageFormat.java
@@ -106,7 +106,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param literal
-	 *            the literal.
+	 *                    the literal.
 	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
@@ -126,7 +126,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param name
-	 *            the name.
+	 *                 the name.
 	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
@@ -146,7 +146,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param value
-	 *            the integer value.
+	 *                  the integer value.
 	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/TextCell.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/TextCell.java
index 0cba860..cceb5e9 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/TextCell.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/TextCell.java
@@ -54,7 +54,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param value
-	 *            the new value of the '<em>Text</em>' attribute.
+	 *                  the new value of the '<em>Text</em>' attribute.
 	 * @see #getText()
 	 * @generated
 	 */
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/TextListItem.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/TextListItem.java
index c803f9f..b4f4736 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/TextListItem.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/TextListItem.java
@@ -59,7 +59,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param value
-	 *            the new value of the '<em>Text</em>' attribute.
+	 *                  the new value of the '<em>Text</em>' attribute.
 	 * @see #getText()
 	 * @generated
 	 */
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/impl/BuiltInTypesPackageImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/impl/BuiltInTypesPackageImpl.java
index 04e76e7..29e473c 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/impl/BuiltInTypesPackageImpl.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/impl/BuiltInTypesPackageImpl.java
@@ -38,6 +38,7 @@
 import org.eclipse.papyrus.model2doc.core.builtintypes.Row;
 import org.eclipse.papyrus.model2doc.core.builtintypes.TextCell;
 import org.eclipse.papyrus.model2doc.core.builtintypes.TextListItem;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
 
 /**
  * <!-- begin-user-doc -->
@@ -213,6 +214,9 @@
 
 		isInited = true;
 
+		// Initialize simple dependencies
+		StylesPackage.eINSTANCE.eClass();
+
 		// Create package meta-data objects
 		theBuiltInTypesPackage.createPackageContents();
 
@@ -639,11 +643,15 @@
 		setNsPrefix(eNS_PREFIX);
 		setNsURI(eNS_URI);
 
+		// Obtain other dependent packages
+		StylesPackage theStylesPackage = (StylesPackage) EPackage.Registry.INSTANCE.getEPackage(StylesPackage.eNS_URI);
+
 		// Create type parameters
 
 		// Set bounds for type parameters
 
 		// Add supertypes to classes
+		cellEClass.getESuperTypes().add(theStylesPackage.getStyledElement());
 		basicTableEClass.getESuperTypes().add(this.getAbstractTable());
 		basicRowEClass.getESuperTypes().add(this.getRow());
 		textCellEClass.getESuperTypes().add(this.getCell());
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/impl/TextCellImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/impl/TextCellImpl.java
index 4b4713c..e601be2 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/impl/TextCellImpl.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/impl/TextCellImpl.java
@@ -13,16 +13,24 @@
  */
 package org.eclipse.papyrus.model2doc.core.builtintypes.impl;
 
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
 import org.eclipse.emf.common.notify.Notification;
 
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EClass;
 
+import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
 
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.papyrus.model2doc.core.builtintypes.BuiltInTypesPackage;
 import org.eclipse.papyrus.model2doc.core.builtintypes.CellLocation;
 import org.eclipse.papyrus.model2doc.core.builtintypes.TextCell;
+import org.eclipse.papyrus.model2doc.core.styles.NamedStyle;
 
 /**
  * <!-- begin-user-doc -->
@@ -32,6 +40,7 @@
  * The following features are implemented:
  * </p>
  * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.builtintypes.impl.TextCellImpl#getNamedStyles <em>Named Styles</em>}</li>
  * <li>{@link org.eclipse.papyrus.model2doc.core.builtintypes.impl.TextCellImpl#getLocation <em>Location</em>}</li>
  * <li>{@link org.eclipse.papyrus.model2doc.core.builtintypes.impl.TextCellImpl#getText <em>Text</em>}</li>
  * </ul>
@@ -40,6 +49,17 @@
  */
 public class TextCellImpl extends MinimalEObjectImpl.Container implements TextCell {
 	/**
+	 * The cached value of the '{@link #getNamedStyles() <em>Named Styles</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getNamedStyles()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<NamedStyle> namedStyles;
+
+	/**
 	 * The default value of the '{@link #getLocation() <em>Location</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -111,6 +131,20 @@
 	 * @generated
 	 */
 	@Override
+	public EList<NamedStyle> getNamedStyles() {
+		if (namedStyles == null) {
+			namedStyles = new EObjectContainmentEList<>(NamedStyle.class, this, BuiltInTypesPackage.TEXT_CELL__NAMED_STYLES);
+		}
+		return namedStyles;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
 	public CellLocation getLocation() {
 		return location;
 	}
@@ -163,8 +197,36 @@
 	 * @generated
 	 */
 	@Override
+	public NamedStyle getNamedStyle(final String name) {
+		return org.eclipse.papyrus.model2doc.core.styles.internal.operations.NamedStyleOperations.INSTANCE.getNamedStyle(getNamedStyles(), name);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+		case BuiltInTypesPackage.TEXT_CELL__NAMED_STYLES:
+			return ((InternalEList<?>) getNamedStyles()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
+		case BuiltInTypesPackage.TEXT_CELL__NAMED_STYLES:
+			return getNamedStyles();
 		case BuiltInTypesPackage.TEXT_CELL__LOCATION:
 			return getLocation();
 		case BuiltInTypesPackage.TEXT_CELL__TEXT:
@@ -179,9 +241,14 @@
 	 *
 	 * @generated
 	 */
+	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
+		case BuiltInTypesPackage.TEXT_CELL__NAMED_STYLES:
+			getNamedStyles().clear();
+			getNamedStyles().addAll((Collection<? extends NamedStyle>) newValue);
+			return;
 		case BuiltInTypesPackage.TEXT_CELL__LOCATION:
 			setLocation((CellLocation) newValue);
 			return;
@@ -201,6 +268,9 @@
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
+		case BuiltInTypesPackage.TEXT_CELL__NAMED_STYLES:
+			getNamedStyles().clear();
+			return;
 		case BuiltInTypesPackage.TEXT_CELL__LOCATION:
 			setLocation(LOCATION_EDEFAULT);
 			return;
@@ -220,6 +290,8 @@
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
+		case BuiltInTypesPackage.TEXT_CELL__NAMED_STYLES:
+			return namedStyles != null && !namedStyles.isEmpty();
 		case BuiltInTypesPackage.TEXT_CELL__LOCATION:
 			return location != LOCATION_EDEFAULT;
 		case BuiltInTypesPackage.TEXT_CELL__TEXT:
@@ -235,6 +307,21 @@
 	 * @generated
 	 */
 	@Override
+	public Object eInvoke(int operationID, EList<?> arguments) throws InvocationTargetException {
+		switch (operationID) {
+		case BuiltInTypesPackage.TEXT_CELL___GET_NAMED_STYLE__STRING:
+			return getNamedStyle((String) arguments.get(0));
+		}
+		return super.eInvoke(operationID, arguments);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
 	public String toString() {
 		if (eIsProxy()) {
 			return super.toString();
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/util/BuiltInTypesAdapterFactory.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/util/BuiltInTypesAdapterFactory.java
index ce8036d..4e3c8f7 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/util/BuiltInTypesAdapterFactory.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/util/BuiltInTypesAdapterFactory.java
@@ -21,6 +21,7 @@
 import org.eclipse.emf.ecore.EObject;
 
 import org.eclipse.papyrus.model2doc.core.builtintypes.*;
+import org.eclipse.papyrus.model2doc.core.styles.StyledElement;
 
 /**
  * <!-- begin-user-doc -->
@@ -143,6 +144,11 @@
 		}
 
 		@Override
+		public Adapter caseStyledElement(StyledElement object) {
+			return createStyledElementAdapter();
+		}
+
+		@Override
 		public Adapter defaultCase(EObject object) {
 			return createEObjectAdapter();
 		}
@@ -154,7 +160,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param target
-	 *            the object to adapt.
+	 *                   the object to adapt.
 	 * @return the adapter for the <code>target</code>.
 	 * @generated
 	 */
@@ -345,6 +351,21 @@
 	}
 
 	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.StyledElement <em>Styled Element</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StyledElement
+	 * @generated
+	 */
+	public Adapter createStyledElementAdapter() {
+		return null;
+	}
+
+	/**
 	 * Creates a new adapter for the default case.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null.
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/util/BuiltInTypesSwitch.java b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/util/BuiltInTypesSwitch.java
index 3979d03..1a4628d 100755
--- a/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/util/BuiltInTypesSwitch.java
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.builtintypes/src-gen/org/eclipse/papyrus/model2doc/core/builtintypes/util/BuiltInTypesSwitch.java
@@ -19,6 +19,7 @@
 import org.eclipse.emf.ecore.util.Switch;
 
 import org.eclipse.papyrus.model2doc.core.builtintypes.*;
+import org.eclipse.papyrus.model2doc.core.styles.StyledElement;
 
 /**
  * <!-- begin-user-doc -->
@@ -63,7 +64,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param ePackage
-	 *            the package in question.
+	 *                     the package in question.
 	 * @return whether this is a switch for the given package.
 	 * @generated
 	 */
@@ -103,6 +104,9 @@
 			Cell cell = (Cell) theEObject;
 			T result = caseCell(cell);
 			if (result == null) {
+				result = caseStyledElement(cell);
+			}
+			if (result == null) {
 				result = defaultCase(theEObject);
 			}
 			return result;
@@ -136,6 +140,9 @@
 				result = caseCell(textCell);
 			}
 			if (result == null) {
+				result = caseStyledElement(textCell);
+			}
+			if (result == null) {
 				result = defaultCase(theEObject);
 			}
 			return result;
@@ -210,7 +217,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Abstract Table</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -227,7 +234,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Row</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -244,7 +251,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Cell</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -261,7 +268,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Basic Table</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -278,7 +285,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Basic Row</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -295,7 +302,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Text Cell</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -312,7 +319,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Abstract List</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -329,7 +336,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>List Item</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -346,7 +353,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Text List Item</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -363,7 +370,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Basic List</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -380,7 +387,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>IFile Reference</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -397,7 +404,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Default File Reference</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -407,6 +414,23 @@
 	}
 
 	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Styled Element</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *                   the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Styled Element</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseStyledElement(StyledElement object) {
+		return null;
+	}
+
+	/**
 	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
@@ -414,7 +438,7 @@
 	 * <!-- end-user-doc -->
 	 *
 	 * @param object
-	 *            the target of the switch.
+	 *                   the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
 	 * @generated
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.classpath b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.classpath
new file mode 100755
index 0000000..23f1e31
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.classpath
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src-gen"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.project b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.project
new file mode 100755
index 0000000..5650987
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.model2doc.core.styles.edit</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+	</natures>
+</projectDescription>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.core.resources.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.core.resources.prefs
new file mode 100755
index 0000000..896a9a5
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
\ No newline at end of file
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.core.runtime.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.core.runtime.prefs
new file mode 100755
index 0000000..5a0ad22
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.core.runtime.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+line.separator=\n
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.jdt.core.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.jdt.core.prefs
new file mode 100755
index 0000000..037f04a
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,319 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=11
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=11
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=11
+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
+org.eclipse.jdt.core.formatter.alignment_for_additive_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_assignment=0
+org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
+org.eclipse.jdt.core.formatter.alignment_for_logical_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_string_concatenation=16
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
+org.eclipse.jdt.core.formatter.comment.line_length=260
+org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
+org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
+org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false
+org.eclipse.jdt.core.formatter.compact_else_if=true
+org.eclipse.jdt.core.formatter.continuation_indentation=2
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
+org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
+org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_empty_lines=false
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_additive_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
+org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_after_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_relational_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert
+org.eclipse.jdt.core.formatter.insert_space_after_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_additive_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_before_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_relational_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation=insert
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.join_lines_in_comments=false
+org.eclipse.jdt.core.formatter.join_wrapped_lines=false
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.lineSplit=260
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=5
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
+org.eclipse.jdt.core.formatter.tabulation.char=tab
+org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.use_on_off_tags=false
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_additive_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_logical_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
+org.eclipse.jdt.core.formatter.wrap_before_string_concatenation=true
+org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.jdt.ui.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.jdt.ui.prefs
new file mode 100755
index 0000000..1a3bd02
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.jdt.ui.prefs
@@ -0,0 +1,127 @@
+cleanup.add_default_serial_version_id=true
+cleanup.add_generated_serial_version_id=false
+cleanup.add_missing_annotations=true
+cleanup.add_missing_deprecated_annotations=true
+cleanup.add_missing_methods=false
+cleanup.add_missing_nls_tags=false
+cleanup.add_missing_override_annotations=true
+cleanup.add_missing_override_annotations_interface_methods=true
+cleanup.add_serial_version_id=false
+cleanup.always_use_blocks=true
+cleanup.always_use_parentheses_in_expressions=false
+cleanup.always_use_this_for_non_static_field_access=false
+cleanup.always_use_this_for_non_static_method_access=false
+cleanup.convert_functional_interfaces=false
+cleanup.convert_to_enhanced_for_loop=false
+cleanup.correct_indentation=false
+cleanup.format_source_code=false
+cleanup.format_source_code_changes_only=false
+cleanup.insert_inferred_type_arguments=false
+cleanup.make_local_variable_final=true
+cleanup.make_parameters_final=false
+cleanup.make_private_fields_final=true
+cleanup.make_type_abstract_if_missing_method=false
+cleanup.make_variable_declarations_final=false
+cleanup.never_use_blocks=false
+cleanup.never_use_parentheses_in_expressions=true
+cleanup.organize_imports=false
+cleanup.qualify_static_field_accesses_with_declaring_class=false
+cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+cleanup.qualify_static_member_accesses_with_declaring_class=true
+cleanup.qualify_static_method_accesses_with_declaring_class=false
+cleanup.remove_private_constructors=true
+cleanup.remove_redundant_type_arguments=true
+cleanup.remove_trailing_whitespaces=true
+cleanup.remove_trailing_whitespaces_all=true
+cleanup.remove_trailing_whitespaces_ignore_empty=false
+cleanup.remove_unnecessary_casts=true
+cleanup.remove_unnecessary_nls_tags=true
+cleanup.remove_unused_imports=true
+cleanup.remove_unused_local_variables=false
+cleanup.remove_unused_private_fields=true
+cleanup.remove_unused_private_members=false
+cleanup.remove_unused_private_methods=true
+cleanup.remove_unused_private_types=true
+cleanup.sort_members=false
+cleanup.sort_members_all=false
+cleanup.use_anonymous_class_creation=false
+cleanup.use_blocks=true
+cleanup.use_blocks_only_for_return_and_throw=false
+cleanup.use_lambda=true
+cleanup.use_parentheses_in_expressions=false
+cleanup.use_this_for_non_static_field_access=false
+cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+cleanup.use_this_for_non_static_method_access=false
+cleanup.use_this_for_non_static_method_access_only_if_necessary=true
+cleanup.use_type_arguments=false
+cleanup_profile=_Papyrus
+cleanup_settings_version=2
+eclipse.preferences.version=1
+editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
+formatter_profile=_Papyrus
+formatter_settings_version=12
+org.eclipse.jdt.ui.ignorelowercasenames=true
+org.eclipse.jdt.ui.importorder=java;javax;org;com;
+org.eclipse.jdt.ui.javadoc=true
+org.eclipse.jdt.ui.ondemandthreshold=99
+org.eclipse.jdt.ui.staticondemandthreshold=99
+org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\n * @return the ${bare_field_name}\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\n * @param ${param} the ${bare_field_name} to set\n */</template><template autoinsert\="false" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\n * Constructor.\n *\n * ${tags}\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*****************************************************************************\n * Copyright (c) ${year} CEA LIST and others.\n * \n * All rights reserved. This program and the accompanying materials\n * are made available under the terms of the Eclipse Public License 2.0\n * which accompanies this distribution, and is available at\n * http\://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n *\n * Contributors\:\n *   CEA LIST - Initial API and implementation\n *   \n *****************************************************************************/\n</template><template autoinsert\="true" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\n *\n * ${tags}\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\n * \n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\n * ${tags}\n */</template><template autoinsert\="false" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/**\n * ${see_to_overridden}\n *\n * ${tags}\n */</template><template autoinsert\="false" context\="delegatecomment_context" deleted\="false" description\="Comment for delegate methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.delegatecomment" name\="delegatecomment">/**\n * ${see_to_target}\n *\n * ${tags}\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\n${package_declaration}\n\n${typecomment}\n${type_declaration}</template><template autoinsert\="true" context\="classbody_context" deleted\="false" description\="Code in new class type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.classbody" name\="classbody">\n</template><template autoinsert\="true" context\="interfacebody_context" deleted\="false" description\="Code in new interface type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.interfacebody" name\="interfacebody">\n</template><template autoinsert\="true" context\="enumbody_context" deleted\="false" description\="Code in new enum type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.enumbody" name\="enumbody">\n</template><template autoinsert\="true" context\="annotationbody_context" deleted\="false" description\="Code in new annotation type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.annotationbody" name\="annotationbody">\n</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates>
+sp_cleanup.add_default_serial_version_id=true
+sp_cleanup.add_generated_serial_version_id=false
+sp_cleanup.add_missing_annotations=true
+sp_cleanup.add_missing_deprecated_annotations=true
+sp_cleanup.add_missing_methods=false
+sp_cleanup.add_missing_nls_tags=false
+sp_cleanup.add_missing_override_annotations=true
+sp_cleanup.add_missing_override_annotations_interface_methods=true
+sp_cleanup.add_serial_version_id=false
+sp_cleanup.always_use_blocks=true
+sp_cleanup.always_use_parentheses_in_expressions=false
+sp_cleanup.always_use_this_for_non_static_field_access=false
+sp_cleanup.always_use_this_for_non_static_method_access=false
+sp_cleanup.convert_functional_interfaces=false
+sp_cleanup.convert_to_enhanced_for_loop=false
+sp_cleanup.correct_indentation=false
+sp_cleanup.format_source_code=true
+sp_cleanup.format_source_code_changes_only=false
+sp_cleanup.insert_inferred_type_arguments=false
+sp_cleanup.make_local_variable_final=true
+sp_cleanup.make_parameters_final=false
+sp_cleanup.make_private_fields_final=true
+sp_cleanup.make_type_abstract_if_missing_method=false
+sp_cleanup.make_variable_declarations_final=false
+sp_cleanup.never_use_blocks=false
+sp_cleanup.never_use_parentheses_in_expressions=true
+sp_cleanup.on_save_use_additional_actions=true
+sp_cleanup.organize_imports=true
+sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
+sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
+sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
+sp_cleanup.remove_private_constructors=true
+sp_cleanup.remove_redundant_modifiers=false
+sp_cleanup.remove_redundant_type_arguments=true
+sp_cleanup.remove_trailing_whitespaces=true
+sp_cleanup.remove_trailing_whitespaces_all=true
+sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
+sp_cleanup.remove_unnecessary_casts=true
+sp_cleanup.remove_unnecessary_nls_tags=true
+sp_cleanup.remove_unused_imports=true
+sp_cleanup.remove_unused_local_variables=false
+sp_cleanup.remove_unused_private_fields=true
+sp_cleanup.remove_unused_private_members=false
+sp_cleanup.remove_unused_private_methods=true
+sp_cleanup.remove_unused_private_types=true
+sp_cleanup.sort_members=false
+sp_cleanup.sort_members_all=false
+sp_cleanup.use_anonymous_class_creation=false
+sp_cleanup.use_blocks=true
+sp_cleanup.use_blocks_only_for_return_and_throw=false
+sp_cleanup.use_lambda=true
+sp_cleanup.use_parentheses_in_expressions=false
+sp_cleanup.use_this_for_non_static_field_access=false
+sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+sp_cleanup.use_this_for_non_static_method_access=false
+sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.pde.api.tools.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.pde.api.tools.prefs
new file mode 100755
index 0000000..b2260f8
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/.settings/org.eclipse.pde.api.tools.prefs
@@ -0,0 +1,104 @@
+ANNOTATION_ELEMENT_TYPE_ADDED_FIELD=Error
+ANNOTATION_ELEMENT_TYPE_ADDED_METHOD_WITHOUT_DEFAULT_VALUE=Error
+ANNOTATION_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+ANNOTATION_ELEMENT_TYPE_REMOVED_FIELD=Error
+ANNOTATION_ELEMENT_TYPE_REMOVED_METHOD=Error
+ANNOTATION_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+API_COMPONENT_ELEMENT_TYPE_REMOVED_API_TYPE=Error
+API_COMPONENT_ELEMENT_TYPE_REMOVED_REEXPORTED_API_TYPE=Warning
+API_COMPONENT_ELEMENT_TYPE_REMOVED_REEXPORTED_TYPE=Warning
+API_COMPONENT_ELEMENT_TYPE_REMOVED_TYPE=Error
+API_USE_SCAN_FIELD_SEVERITY=Error
+API_USE_SCAN_METHOD_SEVERITY=Error
+API_USE_SCAN_TYPE_SEVERITY=Error
+CLASS_ELEMENT_TYPE_ADDED_FIELD=Warning
+CLASS_ELEMENT_TYPE_ADDED_METHOD=Error
+CLASS_ELEMENT_TYPE_ADDED_RESTRICTIONS=Error
+CLASS_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+CLASS_ELEMENT_TYPE_CHANGED_CONTRACTED_SUPERINTERFACES_SET=Error
+CLASS_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+CLASS_ELEMENT_TYPE_CHANGED_NON_ABSTRACT_TO_ABSTRACT=Error
+CLASS_ELEMENT_TYPE_CHANGED_NON_FINAL_TO_FINAL=Error
+CLASS_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+CLASS_ELEMENT_TYPE_REMOVED_CONSTRUCTOR=Error
+CLASS_ELEMENT_TYPE_REMOVED_FIELD=Error
+CLASS_ELEMENT_TYPE_REMOVED_METHOD=Error
+CLASS_ELEMENT_TYPE_REMOVED_SUPERCLASS=Error
+CLASS_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+CLASS_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+CONSTRUCTOR_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+CONSTRUCTOR_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+CONSTRUCTOR_ELEMENT_TYPE_CHANGED_VARARGS_TO_ARRAY=Error
+CONSTRUCTOR_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+ENUM_ELEMENT_TYPE_CHANGED_CONTRACTED_SUPERINTERFACES_SET=Error
+ENUM_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+ENUM_ELEMENT_TYPE_REMOVED_ENUM_CONSTANT=Error
+ENUM_ELEMENT_TYPE_REMOVED_FIELD=Error
+ENUM_ELEMENT_TYPE_REMOVED_METHOD=Error
+ENUM_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+FIELD_ELEMENT_TYPE_ADDED_VALUE=Warning
+FIELD_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+FIELD_ELEMENT_TYPE_CHANGED_FINAL_TO_NON_FINAL_STATIC_CONSTANT=Error
+FIELD_ELEMENT_TYPE_CHANGED_NON_FINAL_TO_FINAL=Error
+FIELD_ELEMENT_TYPE_CHANGED_NON_STATIC_TO_STATIC=Error
+FIELD_ELEMENT_TYPE_CHANGED_STATIC_TO_NON_STATIC=Error
+FIELD_ELEMENT_TYPE_CHANGED_TYPE=Error
+FIELD_ELEMENT_TYPE_CHANGED_VALUE=Warning
+FIELD_ELEMENT_TYPE_REMOVED_TYPE_ARGUMENT=Error
+FIELD_ELEMENT_TYPE_REMOVED_VALUE=Error
+ILLEGAL_EXTEND=Warning
+ILLEGAL_IMPLEMENT=Warning
+ILLEGAL_INSTANTIATE=Warning
+ILLEGAL_OVERRIDE=Warning
+ILLEGAL_REFERENCE=Warning
+INTERFACE_ELEMENT_TYPE_ADDED_DEFAULT_METHOD=Warning
+INTERFACE_ELEMENT_TYPE_ADDED_FIELD=Ignore
+INTERFACE_ELEMENT_TYPE_ADDED_METHOD=Error
+INTERFACE_ELEMENT_TYPE_ADDED_RESTRICTIONS=Error
+INTERFACE_ELEMENT_TYPE_ADDED_SUPER_INTERFACE_WITH_METHODS=Error
+INTERFACE_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+INTERFACE_ELEMENT_TYPE_CHANGED_CONTRACTED_SUPERINTERFACES_SET=Error
+INTERFACE_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_FIELD=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_METHOD=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+INVALID_ANNOTATION=Ignore
+INVALID_JAVADOC_TAG=Ignore
+INVALID_REFERENCE_IN_SYSTEM_LIBRARIES=Ignore
+LEAK_EXTEND=Warning
+LEAK_FIELD_DECL=Warning
+LEAK_IMPLEMENT=Warning
+LEAK_METHOD_PARAM=Warning
+LEAK_METHOD_RETURN_TYPE=Warning
+METHOD_ELEMENT_TYPE_ADDED_RESTRICTIONS=Error
+METHOD_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+METHOD_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+METHOD_ELEMENT_TYPE_CHANGED_NON_ABSTRACT_TO_ABSTRACT=Error
+METHOD_ELEMENT_TYPE_CHANGED_NON_FINAL_TO_FINAL=Error
+METHOD_ELEMENT_TYPE_CHANGED_NON_STATIC_TO_STATIC=Error
+METHOD_ELEMENT_TYPE_CHANGED_STATIC_TO_NON_STATIC=Error
+METHOD_ELEMENT_TYPE_CHANGED_VARARGS_TO_ARRAY=Error
+METHOD_ELEMENT_TYPE_REMOVED_ANNOTATION_DEFAULT_VALUE=Error
+METHOD_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+MISSING_EE_DESCRIPTIONS=Error
+TYPE_PARAMETER_ELEMENT_TYPE_ADDED_CLASS_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_ADDED_INTERFACE_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_CHANGED_CLASS_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_CHANGED_INTERFACE_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_REMOVED_CLASS_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_REMOVED_INTERFACE_BOUND=Error
+UNUSED_PROBLEM_FILTERS=Warning
+automatically_removed_unused_problem_filters=Enabled
+changed_execution_env=Warning
+eclipse.preferences.version=1
+incompatible_api_component_version=Warning
+incompatible_api_component_version_include_major_without_breaking_change=Disabled
+incompatible_api_component_version_include_minor_without_api_change=Disabled
+incompatible_api_component_version_report_major_without_breaking_change=Error
+incompatible_api_component_version_report_minor_without_api_change=Error
+invalid_since_tag_version=Error
+malformed_since_tag=Error
+missing_since_tag=Error
+report_api_breakage_when_major_version_incremented=Disabled
+report_resolution_errors_api_component=Warning
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/META-INF/MANIFEST.MF b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/META-INF/MANIFEST.MF
new file mode 100755
index 0000000..4e40668
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/META-INF/MANIFEST.MF
@@ -0,0 +1,17 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %Bundle-Name
+Bundle-SymbolicName: org.eclipse.papyrus.model2doc.core.styles.edit;singleton:=true
+Automatic-Module-Name: org.eclipse.papyrus.model2doc.core.styles.edit
+Bundle-Version: 0.8.0.qualifier
+Bundle-ClassPath: .
+Bundle-Activator: org.eclipse.papyrus.model2doc.core.styles.provider.StylesEditPlugin$Implementation$Activator
+Bundle-Vendor: %Bundle-Vendor
+Bundle-Localization: plugin
+Bundle-RequiredExecutionEnvironment: JavaSE-11
+Export-Package: org.eclipse.papyrus.model2doc.core.styles.provider
+Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.20.0,4.0.0)";resolution:=optional;x-installation:=greedy,
+ org.eclipse.papyrus.model2doc.core.styles;bundle-version="[0.8.0,1.0.0)",
+ org.eclipse.emf.edit;bundle-version="[2.16.0,3.0.0)"
+Import-Package: org.osgi.framework
+Bundle-ActivationPolicy: lazy
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/about.html b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/about.html
new file mode 100755
index 0000000..ef2872f
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/about.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>November 30, 2017</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0/">https://www.eclipse.org/legal/epl-2.0/</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/build.properties b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/build.properties
new file mode 100755
index 0000000..6e8eb6b
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/build.properties
@@ -0,0 +1,22 @@
+# Copyright (c) 2020 CEA LIST.
+# 
+#  All rights reserved. This program and the accompanying materials
+#  are made available under the terms of the Eclipse Public License 2.0
+#  which accompanies this distribution, and is available at
+#  https://www.eclipse.org/legal/epl-2.0/
+# 
+#  SPDX-License-Identifier: EPL-2.0
+# 
+#  Contributors:
+#  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+
+bin.includes = .,\
+               icons/,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties,\
+               about.html
+jars.compile.order = .
+source.. = src-gen/
+output.. = bin/
+src.includes = about.html
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/BooleanListNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/BooleanListNamedStyle.gif
new file mode 100755
index 0000000..9e9fda8
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/BooleanListNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/BooleanNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/BooleanNamedStyle.gif
new file mode 100755
index 0000000..93ef5ee
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/BooleanNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/DoubleListNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/DoubleListNamedStyle.gif
new file mode 100755
index 0000000..1bd5a2f
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/DoubleListNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/DoubleNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/DoubleNamedStyle.gif
new file mode 100755
index 0000000..f7fd39c
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/DoubleNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/IntListNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/IntListNamedStyle.gif
new file mode 100755
index 0000000..d271678
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/IntListNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/IntNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/IntNamedStyle.gif
new file mode 100755
index 0000000..12efd34
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/IntNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/StringListNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/StringListNamedStyle.gif
new file mode 100755
index 0000000..927a016
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/StringListNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/StringNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/StringNamedStyle.gif
new file mode 100755
index 0000000..f9782de
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/customIcons/full/obj16/StringNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/BooleanListNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/BooleanListNamedStyle.gif
new file mode 100755
index 0000000..9e9fda8
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/BooleanListNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/BooleanNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/BooleanNamedStyle.gif
new file mode 100755
index 0000000..93ef5ee
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/BooleanNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/DoubleListNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/DoubleListNamedStyle.gif
new file mode 100755
index 0000000..1bd5a2f
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/DoubleListNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/DoubleNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/DoubleNamedStyle.gif
new file mode 100755
index 0000000..f7fd39c
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/DoubleNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/IntListNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/IntListNamedStyle.gif
new file mode 100755
index 0000000..d271678
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/IntListNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/IntNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/IntNamedStyle.gif
new file mode 100755
index 0000000..12efd34
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/IntNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/StringListNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/StringListNamedStyle.gif
new file mode 100755
index 0000000..927a016
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/StringListNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/StringNamedStyle.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/StringNamedStyle.gif
new file mode 100755
index 0000000..f9782de
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/icons/full/obj16/StringNamedStyle.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/plugin.properties b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/plugin.properties
new file mode 100755
index 0000000..c12fac2
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/plugin.properties
@@ -0,0 +1,50 @@
+# Copyright (c) 2020 CEA LIST.
+# 
+#  All rights reserved. This program and the accompanying materials
+#  are made available under the terms of the Eclipse Public License 2.0
+#  which accompanies this distribution, and is available at
+#  https://www.eclipse.org/legal/epl-2.0/
+# 
+#  SPDX-License-Identifier: EPL-2.0
+# 
+#  Contributors:
+#  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+
+Bundle-Vendor = Eclipse Modeling Project
+Bundle-Name = Papyrus-Model2Doc - Core Styles Edit (Incubation)
+
+_UI_CreateChild_text = {0}
+_UI_CreateChild_text2 = {1} {0}
+_UI_CreateChild_text3 = {1}
+_UI_CreateChild_tooltip = Create New {0} Under {1} Feature
+_UI_CreateChild_description = Create a new child of type {0} for the {1} feature of the selected {2}.
+_UI_CreateSibling_description = Create a new sibling of type {0} for the selected {2}, under the {1} feature of their parent.
+
+_UI_PropertyDescriptor_description = The {0} of the {1}
+
+_UI_NamedStyle_type = Named Style
+_UI_IntNamedStyle_type = Int Named Style
+_UI_StringNamedStyle_type = String Named Style
+_UI_BooleanNamedStyle_type = Boolean Named Style
+_UI_DoubleNamedStyle_type = Double Named Style
+_UI_IntListNamedStyle_type = Int List Named Style
+_UI_StringListNamedStyle_type = String List Named Style
+_UI_BooleanListNamedStyle_type = Boolean List Named Style
+_UI_DoubleListNamedStyle_type = Double List Named Style
+_UI_StyledElement_type = Styled Element
+_UI_Unknown_type = Object
+
+_UI_Unknown_datatype= Value
+
+_UI_NamedStyle_name_feature = Name
+_UI_IntNamedStyle_value_feature = Value
+_UI_StringNamedStyle_value_feature = Value
+_UI_BooleanNamedStyle_value_feature = Value
+_UI_DoubleNamedStyle_value_feature = Value
+_UI_IntListNamedStyle_values_feature = Values
+_UI_StringListNamedStyle_values_feature = Values
+_UI_BooleanListNamedStyle_values_feature = Values
+_UI_DoubleListNamedStyle_values_feature = Values
+_UI_StyledElement_namedStyles_feature = Named Styles
+_UI_Unknown_feature = Unspecified
+
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/plugin.xml b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/plugin.xml
new file mode 100755
index 0000000..53ae54e
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/plugin.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+ Copyright (c) 2020 CEA LIST.
+ 
+  All rights reserved. This program and the accompanying materials
+  are made available under the terms of the Eclipse Public License 2.0
+  which accompanies this distribution, and is available at
+  https://www.eclipse.org/legal/epl-2.0/
+ 
+  SPDX-License-Identifier: EPL-2.0
+ 
+  Contributors:
+  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+-->
+
+<plugin>
+
+   <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
+      <!-- @generated Styles -->
+      <factory
+            uri="http://www.eclipse.org/papyrus/model2doc/core/1.0.0/Styles"
+            class="org.eclipse.papyrus.model2doc.core.styles.provider.StylesItemProviderAdapterFactory"
+            supportedTypes=
+              "org.eclipse.emf.edit.provider.IEditingDomainItemProvider
+               org.eclipse.emf.edit.provider.IStructuredItemContentProvider
+               org.eclipse.emf.edit.provider.ITreeItemContentProvider
+               org.eclipse.emf.edit.provider.IItemLabelProvider
+               org.eclipse.emf.edit.provider.IItemPropertySource"/>
+   </extension>
+
+</plugin>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/pom.xml b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/pom.xml
new file mode 100755
index 0000000..7c46a93
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/pom.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<groupId>org.eclipse.papyrus.model2doc.plugins-core</groupId>
+		<artifactId>org.eclipse.papyrus.model2doc.plugins.core</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+
+	<artifactId>org.eclipse.papyrus.model2doc.core.styles.edit</artifactId>
+	<version>0.8.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+
+</project>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/BooleanListNamedStyleItemProvider.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/BooleanListNamedStyleItemProvider.java
new file mode 100755
index 0000000..7e76cef
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/BooleanListNamedStyleItemProvider.java
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class BooleanListNamedStyleItemProvider
+		extends ItemProviderAdapter
+		implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public BooleanListNamedStyleItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNamePropertyDescriptor(object);
+			addValuesPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_NamedStyle_name_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_NamedStyle_name_feature", "_UI_NamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.NAMED_STYLE__NAME,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Values feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addValuesPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_BooleanListNamedStyle_values_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_BooleanListNamedStyle_values_feature", "_UI_BooleanListNamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.BOOLEAN_LIST_NAMED_STYLE__VALUES,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This returns BooleanListNamedStyle.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/BooleanListNamedStyle")); //$NON-NLS-1$
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected boolean shouldComposeCreationImage() {
+		return true;
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((BooleanListNamedStyle) object).getName();
+		return label == null || label.length() == 0 ? getString("_UI_BooleanListNamedStyle_type") : //$NON-NLS-1$
+				getString("_UI_BooleanListNamedStyle_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(BooleanListNamedStyle.class)) {
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__NAME:
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__VALUES:
+			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+			return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return StylesEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/BooleanNamedStyleItemProvider.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/BooleanNamedStyleItemProvider.java
new file mode 100755
index 0000000..84827ae
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/BooleanNamedStyleItemProvider.java
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class BooleanNamedStyleItemProvider
+		extends ItemProviderAdapter
+		implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public BooleanNamedStyleItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNamePropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_NamedStyle_name_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_NamedStyle_name_feature", "_UI_NamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.NAMED_STYLE__NAME,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_BooleanNamedStyle_value_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_BooleanNamedStyle_value_feature", "_UI_BooleanNamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.BOOLEAN_NAMED_STYLE__VALUE,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This returns BooleanNamedStyle.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/BooleanNamedStyle")); //$NON-NLS-1$
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected boolean shouldComposeCreationImage() {
+		return true;
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((BooleanNamedStyle) object).getName();
+		return label == null || label.length() == 0 ? getString("_UI_BooleanNamedStyle_type") : //$NON-NLS-1$
+				getString("_UI_BooleanNamedStyle_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(BooleanNamedStyle.class)) {
+		case StylesPackage.BOOLEAN_NAMED_STYLE__NAME:
+		case StylesPackage.BOOLEAN_NAMED_STYLE__VALUE:
+			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+			return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return StylesEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/DoubleListNamedStyleItemProvider.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/DoubleListNamedStyleItemProvider.java
new file mode 100755
index 0000000..50eb723
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/DoubleListNamedStyleItemProvider.java
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class DoubleListNamedStyleItemProvider
+		extends ItemProviderAdapter
+		implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public DoubleListNamedStyleItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNamePropertyDescriptor(object);
+			addValuesPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_NamedStyle_name_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_NamedStyle_name_feature", "_UI_NamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.NAMED_STYLE__NAME,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Values feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addValuesPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_DoubleListNamedStyle_values_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_DoubleListNamedStyle_values_feature", "_UI_DoubleListNamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.DOUBLE_LIST_NAMED_STYLE__VALUES,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.REAL_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This returns DoubleListNamedStyle.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/DoubleListNamedStyle")); //$NON-NLS-1$
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected boolean shouldComposeCreationImage() {
+		return true;
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((DoubleListNamedStyle) object).getName();
+		return label == null || label.length() == 0 ? getString("_UI_DoubleListNamedStyle_type") : //$NON-NLS-1$
+				getString("_UI_DoubleListNamedStyle_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(DoubleListNamedStyle.class)) {
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__NAME:
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__VALUES:
+			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+			return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return StylesEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/DoubleNamedStyleItemProvider.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/DoubleNamedStyleItemProvider.java
new file mode 100755
index 0000000..cc30740
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/DoubleNamedStyleItemProvider.java
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class DoubleNamedStyleItemProvider
+		extends ItemProviderAdapter
+		implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public DoubleNamedStyleItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNamePropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_NamedStyle_name_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_NamedStyle_name_feature", "_UI_NamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.NAMED_STYLE__NAME,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_DoubleNamedStyle_value_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_DoubleNamedStyle_value_feature", "_UI_DoubleNamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.DOUBLE_NAMED_STYLE__VALUE,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.REAL_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This returns DoubleNamedStyle.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/DoubleNamedStyle")); //$NON-NLS-1$
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected boolean shouldComposeCreationImage() {
+		return true;
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((DoubleNamedStyle) object).getName();
+		return label == null || label.length() == 0 ? getString("_UI_DoubleNamedStyle_type") : //$NON-NLS-1$
+				getString("_UI_DoubleNamedStyle_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(DoubleNamedStyle.class)) {
+		case StylesPackage.DOUBLE_NAMED_STYLE__NAME:
+		case StylesPackage.DOUBLE_NAMED_STYLE__VALUE:
+			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+			return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return StylesEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/IntListNamedStyleItemProvider.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/IntListNamedStyleItemProvider.java
new file mode 100755
index 0000000..d121656
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/IntListNamedStyleItemProvider.java
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class IntListNamedStyleItemProvider
+		extends ItemProviderAdapter
+		implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public IntListNamedStyleItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNamePropertyDescriptor(object);
+			addValuesPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_NamedStyle_name_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_NamedStyle_name_feature", "_UI_NamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.NAMED_STYLE__NAME,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Values feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addValuesPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_IntListNamedStyle_values_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_IntListNamedStyle_values_feature", "_UI_IntListNamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.INT_LIST_NAMED_STYLE__VALUES,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This returns IntListNamedStyle.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/IntListNamedStyle")); //$NON-NLS-1$
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected boolean shouldComposeCreationImage() {
+		return true;
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((IntListNamedStyle) object).getName();
+		return label == null || label.length() == 0 ? getString("_UI_IntListNamedStyle_type") : //$NON-NLS-1$
+				getString("_UI_IntListNamedStyle_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(IntListNamedStyle.class)) {
+		case StylesPackage.INT_LIST_NAMED_STYLE__NAME:
+		case StylesPackage.INT_LIST_NAMED_STYLE__VALUES:
+			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+			return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return StylesEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/IntNamedStyleItemProvider.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/IntNamedStyleItemProvider.java
new file mode 100755
index 0000000..4df2f64
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/IntNamedStyleItemProvider.java
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class IntNamedStyleItemProvider
+		extends ItemProviderAdapter
+		implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public IntNamedStyleItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNamePropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_NamedStyle_name_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_NamedStyle_name_feature", "_UI_NamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.NAMED_STYLE__NAME,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_IntNamedStyle_value_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_IntNamedStyle_value_feature", "_UI_IntNamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.INT_NAMED_STYLE__VALUE,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.INTEGRAL_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This returns IntNamedStyle.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/IntNamedStyle")); //$NON-NLS-1$
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected boolean shouldComposeCreationImage() {
+		return true;
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((IntNamedStyle) object).getName();
+		return label == null || label.length() == 0 ? getString("_UI_IntNamedStyle_type") : //$NON-NLS-1$
+				getString("_UI_IntNamedStyle_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(IntNamedStyle.class)) {
+		case StylesPackage.INT_NAMED_STYLE__NAME:
+		case StylesPackage.INT_NAMED_STYLE__VALUE:
+			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+			return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return StylesEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StringListNamedStyleItemProvider.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StringListNamedStyleItemProvider.java
new file mode 100755
index 0000000..3d01834
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StringListNamedStyleItemProvider.java
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class StringListNamedStyleItemProvider
+		extends ItemProviderAdapter
+		implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public StringListNamedStyleItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNamePropertyDescriptor(object);
+			addValuesPropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_NamedStyle_name_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_NamedStyle_name_feature", "_UI_NamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.NAMED_STYLE__NAME,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Values feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addValuesPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_StringListNamedStyle_values_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_StringListNamedStyle_values_feature", "_UI_StringListNamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.STRING_LIST_NAMED_STYLE__VALUES,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This returns StringListNamedStyle.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/StringListNamedStyle")); //$NON-NLS-1$
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected boolean shouldComposeCreationImage() {
+		return true;
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((StringListNamedStyle) object).getName();
+		return label == null || label.length() == 0 ? getString("_UI_StringListNamedStyle_type") : //$NON-NLS-1$
+				getString("_UI_StringListNamedStyle_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(StringListNamedStyle.class)) {
+		case StylesPackage.STRING_LIST_NAMED_STYLE__NAME:
+		case StylesPackage.STRING_LIST_NAMED_STYLE__VALUES:
+			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+			return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return StylesEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StringNamedStyleItemProvider.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StringNamedStyleItemProvider.java
new file mode 100755
index 0000000..df7eac6
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StringNamedStyleItemProvider.java
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemProviderAdapter;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class StringNamedStyleItemProvider
+		extends ItemProviderAdapter
+		implements
+		IEditingDomainItemProvider,
+		IStructuredItemContentProvider,
+		ITreeItemContentProvider,
+		IItemLabelProvider,
+		IItemPropertySource {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public StringNamedStyleItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addNamePropertyDescriptor(object);
+			addValuePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_NamedStyle_name_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_NamedStyle_name_feature", "_UI_NamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.NAMED_STYLE__NAME,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add(createItemPropertyDescriptor(((ComposeableAdapterFactory) adapterFactory).getRootAdapterFactory(),
+				getResourceLocator(),
+				getString("_UI_StringNamedStyle_value_feature"), //$NON-NLS-1$
+				getString("_UI_PropertyDescriptor_description", "_UI_StringNamedStyle_value_feature", "_UI_StringNamedStyle_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				StylesPackage.Literals.STRING_NAMED_STYLE__VALUE,
+				true,
+				false,
+				false,
+				ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				null,
+				null));
+	}
+
+	/**
+	 * This returns StringNamedStyle.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/StringNamedStyle")); //$NON-NLS-1$
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected boolean shouldComposeCreationImage() {
+		return true;
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		String label = ((StringNamedStyle) object).getName();
+		return label == null || label.length() == 0 ? getString("_UI_StringNamedStyle_type") : //$NON-NLS-1$
+				getString("_UI_StringNamedStyle_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(StringNamedStyle.class)) {
+		case StylesPackage.STRING_NAMED_STYLE__NAME:
+		case StylesPackage.STRING_NAMED_STYLE__VALUE:
+			fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+			return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return StylesEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StylesEditPlugin.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StylesEditPlugin.java
new file mode 100755
index 0000000..c21ff1f
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StylesEditPlugin.java
@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+import org.eclipse.emf.common.EMFPlugin;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.osgi.framework.BundleActivator;
+
+/**
+ * This is the central singleton for the Styles edit plugin.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public final class StylesEditPlugin extends EMFPlugin {
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public static final StylesEditPlugin INSTANCE = new StylesEditPlugin();
+
+	/**
+	 * Keep track of the singleton.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private static Implementation plugin;
+
+	/**
+	 * Create the instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public StylesEditPlugin() {
+		super(new ResourceLocator[] {
+		});
+	}
+
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getPluginResourceLocator() {
+		return plugin;
+	}
+
+	/**
+	 * Returns the singleton instance of the Eclipse plugin.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the singleton instance.
+	 * @generated
+	 */
+	public static Implementation getPlugin() {
+		return plugin;
+	}
+
+	/**
+	 * The actual implementation of the Eclipse <b>Plugin</b>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public static class Implementation extends EclipsePlugin {
+		/**
+		 * Creates an instance.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		public Implementation() {
+			super();
+
+			// Remember the static instance.
+			//
+			plugin = this;
+		}
+
+		/**
+		 * The actual implementation of the purely OSGi-compatible <b>Bundle Activator</b>.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		public static final class Activator extends EMFPlugin.OSGiDelegatingBundleActivator {
+			@Override
+			protected BundleActivator createBundle() {
+				return new Implementation();
+			}
+		}
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StylesItemProviderAdapterFactory.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StylesItemProviderAdapterFactory.java
new file mode 100755
index 0000000..7d24263
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen/org/eclipse/papyrus/model2doc/core/styles/provider/StylesItemProviderAdapterFactory.java
@@ -0,0 +1,424 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.provider;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.edit.provider.ChangeNotifier;
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.IChangeNotifier;
+import org.eclipse.emf.edit.provider.IDisposable;
+import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
+import org.eclipse.emf.edit.provider.IItemLabelProvider;
+import org.eclipse.emf.edit.provider.IItemPropertySource;
+import org.eclipse.emf.edit.provider.INotifyChangedListener;
+import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
+import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
+
+import org.eclipse.papyrus.model2doc.core.styles.util.StylesAdapterFactory;
+
+/**
+ * This is the factory that is used to provide the interfaces needed to support Viewers.
+ * The adapters generated by this factory convert EMF adapter notifications into calls to {@link #fireNotifyChanged fireNotifyChanged}.
+ * The adapters also support Eclipse property sheets.
+ * Note that most of the adapters are shared among multiple instances.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class StylesItemProviderAdapterFactory extends StylesAdapterFactory implements ComposeableAdapterFactory, IChangeNotifier, IDisposable {
+	/**
+	 * This keeps track of the root adapter factory that delegates to this adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected ComposedAdapterFactory parentAdapterFactory;
+
+	/**
+	 * This is used to implement {@link org.eclipse.emf.edit.provider.IChangeNotifier}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected IChangeNotifier changeNotifier = new ChangeNotifier();
+
+	/**
+	 * This keeps track of all the supported types checked by {@link #isFactoryForType isFactoryForType}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected Collection<Object> supportedTypes = new ArrayList<Object>();
+
+	/**
+	 * This constructs an instance.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public StylesItemProviderAdapterFactory() {
+		supportedTypes.add(IEditingDomainItemProvider.class);
+		supportedTypes.add(IStructuredItemContentProvider.class);
+		supportedTypes.add(ITreeItemContentProvider.class);
+		supportedTypes.add(IItemLabelProvider.class);
+		supportedTypes.add(IItemPropertySource.class);
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected IntNamedStyleItemProvider intNamedStyleItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Adapter createIntNamedStyleAdapter() {
+		if (intNamedStyleItemProvider == null) {
+			intNamedStyleItemProvider = new IntNamedStyleItemProvider(this);
+		}
+
+		return intNamedStyleItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected StringNamedStyleItemProvider stringNamedStyleItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Adapter createStringNamedStyleAdapter() {
+		if (stringNamedStyleItemProvider == null) {
+			stringNamedStyleItemProvider = new StringNamedStyleItemProvider(this);
+		}
+
+		return stringNamedStyleItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected BooleanNamedStyleItemProvider booleanNamedStyleItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Adapter createBooleanNamedStyleAdapter() {
+		if (booleanNamedStyleItemProvider == null) {
+			booleanNamedStyleItemProvider = new BooleanNamedStyleItemProvider(this);
+		}
+
+		return booleanNamedStyleItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected DoubleNamedStyleItemProvider doubleNamedStyleItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Adapter createDoubleNamedStyleAdapter() {
+		if (doubleNamedStyleItemProvider == null) {
+			doubleNamedStyleItemProvider = new DoubleNamedStyleItemProvider(this);
+		}
+
+		return doubleNamedStyleItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected IntListNamedStyleItemProvider intListNamedStyleItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Adapter createIntListNamedStyleAdapter() {
+		if (intListNamedStyleItemProvider == null) {
+			intListNamedStyleItemProvider = new IntListNamedStyleItemProvider(this);
+		}
+
+		return intListNamedStyleItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected StringListNamedStyleItemProvider stringListNamedStyleItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Adapter createStringListNamedStyleAdapter() {
+		if (stringListNamedStyleItemProvider == null) {
+			stringListNamedStyleItemProvider = new StringListNamedStyleItemProvider(this);
+		}
+
+		return stringListNamedStyleItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected BooleanListNamedStyleItemProvider booleanListNamedStyleItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Adapter createBooleanListNamedStyleAdapter() {
+		if (booleanListNamedStyleItemProvider == null) {
+			booleanListNamedStyleItemProvider = new BooleanListNamedStyleItemProvider(this);
+		}
+
+		return booleanListNamedStyleItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected DoubleListNamedStyleItemProvider doubleListNamedStyleItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Adapter createDoubleListNamedStyleAdapter() {
+		if (doubleListNamedStyleItemProvider == null) {
+			doubleListNamedStyleItemProvider = new DoubleListNamedStyleItemProvider(this);
+		}
+
+		return doubleListNamedStyleItemProvider;
+	}
+
+	/**
+	 * This returns the root adapter factory that contains this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public ComposeableAdapterFactory getRootAdapterFactory() {
+		return parentAdapterFactory == null ? this : parentAdapterFactory.getRootAdapterFactory();
+	}
+
+	/**
+	 * This sets the composed adapter factory that contains this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
+		this.parentAdapterFactory = parentAdapterFactory;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object type) {
+		return supportedTypes.contains(type) || super.isFactoryForType(type);
+	}
+
+	/**
+	 * This implementation substitutes the factory itself as the key for the adapter.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Adapter adapt(Notifier notifier, Object type) {
+		return super.adapt(notifier, this);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object adapt(Object object, Object type) {
+		if (isFactoryForType(type)) {
+			Object adapter = super.adapt(object, type);
+			if (!(type instanceof Class<?>) || (((Class<?>) type).isInstance(adapter))) {
+				return adapter;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * This adds a listener.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public void addListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.addListener(notifyChangedListener);
+	}
+
+	/**
+	 * This removes a listener.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public void removeListener(INotifyChangedListener notifyChangedListener) {
+		changeNotifier.removeListener(notifyChangedListener);
+	}
+
+	/**
+	 * This delegates to {@link #changeNotifier} and to {@link #parentAdapterFactory}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public void fireNotifyChanged(Notification notification) {
+		changeNotifier.fireNotifyChanged(notification);
+
+		if (parentAdapterFactory != null) {
+			parentAdapterFactory.fireNotifyChanged(notification);
+		}
+	}
+
+	/**
+	 * This disposes all of the item providers created by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public void dispose() {
+		if (intNamedStyleItemProvider != null) {
+			intNamedStyleItemProvider.dispose();
+		}
+		if (stringNamedStyleItemProvider != null) {
+			stringNamedStyleItemProvider.dispose();
+		}
+		if (booleanNamedStyleItemProvider != null) {
+			booleanNamedStyleItemProvider.dispose();
+		}
+		if (doubleNamedStyleItemProvider != null) {
+			doubleNamedStyleItemProvider.dispose();
+		}
+		if (intListNamedStyleItemProvider != null) {
+			intListNamedStyleItemProvider.dispose();
+		}
+		if (stringListNamedStyleItemProvider != null) {
+			stringListNamedStyleItemProvider.dispose();
+		}
+		if (booleanListNamedStyleItemProvider != null) {
+			booleanListNamedStyleItemProvider.dispose();
+		}
+		if (doubleListNamedStyleItemProvider != null) {
+			doubleListNamedStyleItemProvider.dispose();
+		}
+	}
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.classpath b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.classpath
new file mode 100755
index 0000000..9909fb1
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.classpath
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src-gen"/>
+	<classpathentry kind="src" path="api"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.project b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.project
new file mode 100755
index 0000000..70e1bdf
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.model2doc.core.styles</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.core.resources.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.core.resources.prefs
new file mode 100755
index 0000000..896a9a5
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8
\ No newline at end of file
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.core.runtime.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.core.runtime.prefs
new file mode 100755
index 0000000..5a0ad22
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.core.runtime.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+line.separator=\n
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.jdt.core.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.jdt.core.prefs
new file mode 100755
index 0000000..037f04a
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,319 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=11
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=11
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=11
+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
+org.eclipse.jdt.core.formatter.alignment_for_additive_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_assignment=0
+org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
+org.eclipse.jdt.core.formatter.alignment_for_logical_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_string_concatenation=16
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
+org.eclipse.jdt.core.formatter.comment.line_length=260
+org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
+org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
+org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false
+org.eclipse.jdt.core.formatter.compact_else_if=true
+org.eclipse.jdt.core.formatter.continuation_indentation=2
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
+org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
+org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_empty_lines=false
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_additive_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
+org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_after_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_relational_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert
+org.eclipse.jdt.core.formatter.insert_space_after_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_additive_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_before_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_relational_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation=insert
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.join_lines_in_comments=false
+org.eclipse.jdt.core.formatter.join_wrapped_lines=false
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.lineSplit=260
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=5
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
+org.eclipse.jdt.core.formatter.tabulation.char=tab
+org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.use_on_off_tags=false
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_additive_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_logical_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
+org.eclipse.jdt.core.formatter.wrap_before_string_concatenation=true
+org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.jdt.ui.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.jdt.ui.prefs
new file mode 100755
index 0000000..1a3bd02
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.jdt.ui.prefs
@@ -0,0 +1,127 @@
+cleanup.add_default_serial_version_id=true
+cleanup.add_generated_serial_version_id=false
+cleanup.add_missing_annotations=true
+cleanup.add_missing_deprecated_annotations=true
+cleanup.add_missing_methods=false
+cleanup.add_missing_nls_tags=false
+cleanup.add_missing_override_annotations=true
+cleanup.add_missing_override_annotations_interface_methods=true
+cleanup.add_serial_version_id=false
+cleanup.always_use_blocks=true
+cleanup.always_use_parentheses_in_expressions=false
+cleanup.always_use_this_for_non_static_field_access=false
+cleanup.always_use_this_for_non_static_method_access=false
+cleanup.convert_functional_interfaces=false
+cleanup.convert_to_enhanced_for_loop=false
+cleanup.correct_indentation=false
+cleanup.format_source_code=false
+cleanup.format_source_code_changes_only=false
+cleanup.insert_inferred_type_arguments=false
+cleanup.make_local_variable_final=true
+cleanup.make_parameters_final=false
+cleanup.make_private_fields_final=true
+cleanup.make_type_abstract_if_missing_method=false
+cleanup.make_variable_declarations_final=false
+cleanup.never_use_blocks=false
+cleanup.never_use_parentheses_in_expressions=true
+cleanup.organize_imports=false
+cleanup.qualify_static_field_accesses_with_declaring_class=false
+cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+cleanup.qualify_static_member_accesses_with_declaring_class=true
+cleanup.qualify_static_method_accesses_with_declaring_class=false
+cleanup.remove_private_constructors=true
+cleanup.remove_redundant_type_arguments=true
+cleanup.remove_trailing_whitespaces=true
+cleanup.remove_trailing_whitespaces_all=true
+cleanup.remove_trailing_whitespaces_ignore_empty=false
+cleanup.remove_unnecessary_casts=true
+cleanup.remove_unnecessary_nls_tags=true
+cleanup.remove_unused_imports=true
+cleanup.remove_unused_local_variables=false
+cleanup.remove_unused_private_fields=true
+cleanup.remove_unused_private_members=false
+cleanup.remove_unused_private_methods=true
+cleanup.remove_unused_private_types=true
+cleanup.sort_members=false
+cleanup.sort_members_all=false
+cleanup.use_anonymous_class_creation=false
+cleanup.use_blocks=true
+cleanup.use_blocks_only_for_return_and_throw=false
+cleanup.use_lambda=true
+cleanup.use_parentheses_in_expressions=false
+cleanup.use_this_for_non_static_field_access=false
+cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+cleanup.use_this_for_non_static_method_access=false
+cleanup.use_this_for_non_static_method_access_only_if_necessary=true
+cleanup.use_type_arguments=false
+cleanup_profile=_Papyrus
+cleanup_settings_version=2
+eclipse.preferences.version=1
+editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
+formatter_profile=_Papyrus
+formatter_settings_version=12
+org.eclipse.jdt.ui.ignorelowercasenames=true
+org.eclipse.jdt.ui.importorder=java;javax;org;com;
+org.eclipse.jdt.ui.javadoc=true
+org.eclipse.jdt.ui.ondemandthreshold=99
+org.eclipse.jdt.ui.staticondemandthreshold=99
+org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\n * @return the ${bare_field_name}\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\n * @param ${param} the ${bare_field_name} to set\n */</template><template autoinsert\="false" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\n * Constructor.\n *\n * ${tags}\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*****************************************************************************\n * Copyright (c) ${year} CEA LIST and others.\n * \n * All rights reserved. This program and the accompanying materials\n * are made available under the terms of the Eclipse Public License 2.0\n * which accompanies this distribution, and is available at\n * http\://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n *\n * Contributors\:\n *   CEA LIST - Initial API and implementation\n *   \n *****************************************************************************/\n</template><template autoinsert\="true" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\n *\n * ${tags}\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\n * \n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\n * ${tags}\n */</template><template autoinsert\="false" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/**\n * ${see_to_overridden}\n *\n * ${tags}\n */</template><template autoinsert\="false" context\="delegatecomment_context" deleted\="false" description\="Comment for delegate methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.delegatecomment" name\="delegatecomment">/**\n * ${see_to_target}\n *\n * ${tags}\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\n${package_declaration}\n\n${typecomment}\n${type_declaration}</template><template autoinsert\="true" context\="classbody_context" deleted\="false" description\="Code in new class type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.classbody" name\="classbody">\n</template><template autoinsert\="true" context\="interfacebody_context" deleted\="false" description\="Code in new interface type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.interfacebody" name\="interfacebody">\n</template><template autoinsert\="true" context\="enumbody_context" deleted\="false" description\="Code in new enum type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.enumbody" name\="enumbody">\n</template><template autoinsert\="true" context\="annotationbody_context" deleted\="false" description\="Code in new annotation type bodies" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.annotationbody" name\="annotationbody">\n</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates>
+sp_cleanup.add_default_serial_version_id=true
+sp_cleanup.add_generated_serial_version_id=false
+sp_cleanup.add_missing_annotations=true
+sp_cleanup.add_missing_deprecated_annotations=true
+sp_cleanup.add_missing_methods=false
+sp_cleanup.add_missing_nls_tags=false
+sp_cleanup.add_missing_override_annotations=true
+sp_cleanup.add_missing_override_annotations_interface_methods=true
+sp_cleanup.add_serial_version_id=false
+sp_cleanup.always_use_blocks=true
+sp_cleanup.always_use_parentheses_in_expressions=false
+sp_cleanup.always_use_this_for_non_static_field_access=false
+sp_cleanup.always_use_this_for_non_static_method_access=false
+sp_cleanup.convert_functional_interfaces=false
+sp_cleanup.convert_to_enhanced_for_loop=false
+sp_cleanup.correct_indentation=false
+sp_cleanup.format_source_code=true
+sp_cleanup.format_source_code_changes_only=false
+sp_cleanup.insert_inferred_type_arguments=false
+sp_cleanup.make_local_variable_final=true
+sp_cleanup.make_parameters_final=false
+sp_cleanup.make_private_fields_final=true
+sp_cleanup.make_type_abstract_if_missing_method=false
+sp_cleanup.make_variable_declarations_final=false
+sp_cleanup.never_use_blocks=false
+sp_cleanup.never_use_parentheses_in_expressions=true
+sp_cleanup.on_save_use_additional_actions=true
+sp_cleanup.organize_imports=true
+sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
+sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
+sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
+sp_cleanup.remove_private_constructors=true
+sp_cleanup.remove_redundant_modifiers=false
+sp_cleanup.remove_redundant_type_arguments=true
+sp_cleanup.remove_trailing_whitespaces=true
+sp_cleanup.remove_trailing_whitespaces_all=true
+sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
+sp_cleanup.remove_unnecessary_casts=true
+sp_cleanup.remove_unnecessary_nls_tags=true
+sp_cleanup.remove_unused_imports=true
+sp_cleanup.remove_unused_local_variables=false
+sp_cleanup.remove_unused_private_fields=true
+sp_cleanup.remove_unused_private_members=false
+sp_cleanup.remove_unused_private_methods=true
+sp_cleanup.remove_unused_private_types=true
+sp_cleanup.sort_members=false
+sp_cleanup.sort_members_all=false
+sp_cleanup.use_anonymous_class_creation=false
+sp_cleanup.use_blocks=true
+sp_cleanup.use_blocks_only_for_return_and_throw=false
+sp_cleanup.use_lambda=true
+sp_cleanup.use_parentheses_in_expressions=false
+sp_cleanup.use_this_for_non_static_field_access=false
+sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+sp_cleanup.use_this_for_non_static_method_access=false
+sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.pde.api.tools.prefs b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.pde.api.tools.prefs
new file mode 100755
index 0000000..b2260f8
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/.settings/org.eclipse.pde.api.tools.prefs
@@ -0,0 +1,104 @@
+ANNOTATION_ELEMENT_TYPE_ADDED_FIELD=Error
+ANNOTATION_ELEMENT_TYPE_ADDED_METHOD_WITHOUT_DEFAULT_VALUE=Error
+ANNOTATION_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+ANNOTATION_ELEMENT_TYPE_REMOVED_FIELD=Error
+ANNOTATION_ELEMENT_TYPE_REMOVED_METHOD=Error
+ANNOTATION_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+API_COMPONENT_ELEMENT_TYPE_REMOVED_API_TYPE=Error
+API_COMPONENT_ELEMENT_TYPE_REMOVED_REEXPORTED_API_TYPE=Warning
+API_COMPONENT_ELEMENT_TYPE_REMOVED_REEXPORTED_TYPE=Warning
+API_COMPONENT_ELEMENT_TYPE_REMOVED_TYPE=Error
+API_USE_SCAN_FIELD_SEVERITY=Error
+API_USE_SCAN_METHOD_SEVERITY=Error
+API_USE_SCAN_TYPE_SEVERITY=Error
+CLASS_ELEMENT_TYPE_ADDED_FIELD=Warning
+CLASS_ELEMENT_TYPE_ADDED_METHOD=Error
+CLASS_ELEMENT_TYPE_ADDED_RESTRICTIONS=Error
+CLASS_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+CLASS_ELEMENT_TYPE_CHANGED_CONTRACTED_SUPERINTERFACES_SET=Error
+CLASS_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+CLASS_ELEMENT_TYPE_CHANGED_NON_ABSTRACT_TO_ABSTRACT=Error
+CLASS_ELEMENT_TYPE_CHANGED_NON_FINAL_TO_FINAL=Error
+CLASS_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+CLASS_ELEMENT_TYPE_REMOVED_CONSTRUCTOR=Error
+CLASS_ELEMENT_TYPE_REMOVED_FIELD=Error
+CLASS_ELEMENT_TYPE_REMOVED_METHOD=Error
+CLASS_ELEMENT_TYPE_REMOVED_SUPERCLASS=Error
+CLASS_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+CLASS_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+CONSTRUCTOR_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+CONSTRUCTOR_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+CONSTRUCTOR_ELEMENT_TYPE_CHANGED_VARARGS_TO_ARRAY=Error
+CONSTRUCTOR_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+ENUM_ELEMENT_TYPE_CHANGED_CONTRACTED_SUPERINTERFACES_SET=Error
+ENUM_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+ENUM_ELEMENT_TYPE_REMOVED_ENUM_CONSTANT=Error
+ENUM_ELEMENT_TYPE_REMOVED_FIELD=Error
+ENUM_ELEMENT_TYPE_REMOVED_METHOD=Error
+ENUM_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+FIELD_ELEMENT_TYPE_ADDED_VALUE=Warning
+FIELD_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+FIELD_ELEMENT_TYPE_CHANGED_FINAL_TO_NON_FINAL_STATIC_CONSTANT=Error
+FIELD_ELEMENT_TYPE_CHANGED_NON_FINAL_TO_FINAL=Error
+FIELD_ELEMENT_TYPE_CHANGED_NON_STATIC_TO_STATIC=Error
+FIELD_ELEMENT_TYPE_CHANGED_STATIC_TO_NON_STATIC=Error
+FIELD_ELEMENT_TYPE_CHANGED_TYPE=Error
+FIELD_ELEMENT_TYPE_CHANGED_VALUE=Warning
+FIELD_ELEMENT_TYPE_REMOVED_TYPE_ARGUMENT=Error
+FIELD_ELEMENT_TYPE_REMOVED_VALUE=Error
+ILLEGAL_EXTEND=Warning
+ILLEGAL_IMPLEMENT=Warning
+ILLEGAL_INSTANTIATE=Warning
+ILLEGAL_OVERRIDE=Warning
+ILLEGAL_REFERENCE=Warning
+INTERFACE_ELEMENT_TYPE_ADDED_DEFAULT_METHOD=Warning
+INTERFACE_ELEMENT_TYPE_ADDED_FIELD=Ignore
+INTERFACE_ELEMENT_TYPE_ADDED_METHOD=Error
+INTERFACE_ELEMENT_TYPE_ADDED_RESTRICTIONS=Error
+INTERFACE_ELEMENT_TYPE_ADDED_SUPER_INTERFACE_WITH_METHODS=Error
+INTERFACE_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+INTERFACE_ELEMENT_TYPE_CHANGED_CONTRACTED_SUPERINTERFACES_SET=Error
+INTERFACE_ELEMENT_TYPE_CHANGED_TYPE_CONVERSION=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_FIELD=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_METHOD=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_TYPE_MEMBER=Error
+INTERFACE_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+INVALID_ANNOTATION=Ignore
+INVALID_JAVADOC_TAG=Ignore
+INVALID_REFERENCE_IN_SYSTEM_LIBRARIES=Ignore
+LEAK_EXTEND=Warning
+LEAK_FIELD_DECL=Warning
+LEAK_IMPLEMENT=Warning
+LEAK_METHOD_PARAM=Warning
+LEAK_METHOD_RETURN_TYPE=Warning
+METHOD_ELEMENT_TYPE_ADDED_RESTRICTIONS=Error
+METHOD_ELEMENT_TYPE_ADDED_TYPE_PARAMETER=Error
+METHOD_ELEMENT_TYPE_CHANGED_DECREASE_ACCESS=Error
+METHOD_ELEMENT_TYPE_CHANGED_NON_ABSTRACT_TO_ABSTRACT=Error
+METHOD_ELEMENT_TYPE_CHANGED_NON_FINAL_TO_FINAL=Error
+METHOD_ELEMENT_TYPE_CHANGED_NON_STATIC_TO_STATIC=Error
+METHOD_ELEMENT_TYPE_CHANGED_STATIC_TO_NON_STATIC=Error
+METHOD_ELEMENT_TYPE_CHANGED_VARARGS_TO_ARRAY=Error
+METHOD_ELEMENT_TYPE_REMOVED_ANNOTATION_DEFAULT_VALUE=Error
+METHOD_ELEMENT_TYPE_REMOVED_TYPE_PARAMETER=Error
+MISSING_EE_DESCRIPTIONS=Error
+TYPE_PARAMETER_ELEMENT_TYPE_ADDED_CLASS_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_ADDED_INTERFACE_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_CHANGED_CLASS_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_CHANGED_INTERFACE_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_REMOVED_CLASS_BOUND=Error
+TYPE_PARAMETER_ELEMENT_TYPE_REMOVED_INTERFACE_BOUND=Error
+UNUSED_PROBLEM_FILTERS=Warning
+automatically_removed_unused_problem_filters=Enabled
+changed_execution_env=Warning
+eclipse.preferences.version=1
+incompatible_api_component_version=Warning
+incompatible_api_component_version_include_major_without_breaking_change=Disabled
+incompatible_api_component_version_include_minor_without_api_change=Disabled
+incompatible_api_component_version_report_major_without_breaking_change=Error
+incompatible_api_component_version_report_minor_without_api_change=Error
+invalid_since_tag_version=Error
+malformed_since_tag=Error
+missing_since_tag=Error
+report_api_breakage_when_major_version_incremented=Disabled
+report_resolution_errors_api_component=Warning
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/META-INF/MANIFEST.MF b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/META-INF/MANIFEST.MF
new file mode 100755
index 0000000..8e2baf3
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/META-INF/MANIFEST.MF
@@ -0,0 +1,18 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %Bundle-Name
+Bundle-SymbolicName: org.eclipse.papyrus.model2doc.core.styles;singleton:=true
+Bundle-Version: 0.8.0.qualifier
+Bundle-ClassPath: .
+Bundle-Vendor: %Bundle-Vendor
+Bundle-Localization: plugin
+Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.18.0,4.0.0)";x-installation:=greedy;resolution:=optional,
+ org.eclipse.emf.ecore;bundle-version="[2.23.0,3.0.0)",
+ org.eclipse.papyrus.uml.extensionpoints;bundle-version="[1.3.0,3.0.0)"
+Bundle-RequiredExecutionEnvironment: JavaSE-11
+Export-Package: org.eclipse.papyrus.model2doc.core.styles,
+ org.eclipse.papyrus.model2doc.core.styles.impl,
+ org.eclipse.papyrus.model2doc.core.styles.internal.operations,
+ org.eclipse.papyrus.model2doc.core.styles.util
+Automatic-Module-Name: org.eclipse.papyrus.model2doc.core.styles
+Bundle-ActivationPolicy: lazy
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/about.html b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/about.html
new file mode 100755
index 0000000..ef2872f
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/about.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>November 30, 2017</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0/">https://www.eclipse.org/legal/epl-2.0/</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/api/org/eclipse/papyrus/model2doc/core/styles/internal/operations/NamedStyleOperations.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/api/org/eclipse/papyrus/model2doc/core/styles/internal/operations/NamedStyleOperations.java
new file mode 100755
index 0000000..83eebdf
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/api/org/eclipse/papyrus/model2doc/core/styles/internal/operations/NamedStyleOperations.java
@@ -0,0 +1,58 @@
+/*****************************************************************************
+ * Copyright (c) 2020 CEA LIST and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ *
+ *****************************************************************************/
+
+package org.eclipse.papyrus.model2doc.core.styles.internal.operations;
+
+import java.util.List;
+
+import org.eclipse.papyrus.model2doc.core.styles.NamedStyle;
+
+/**
+ * This class provide method to about Styles
+ */
+public final class NamedStyleOperations {
+
+	/**
+	 * Singleton of this class
+	 */
+	public static final NamedStyleOperations INSTANCE = new NamedStyleOperations();
+
+	/**
+	 *
+	 * Constructor.
+	 * protected to allow to extend this class if required
+	 */
+	protected NamedStyleOperations() {
+		// nothing to do
+	}
+
+	/**
+	 *
+	 * @param namedStyles
+	 *            a list of named style
+	 * @param name
+	 *            the name of the wanted named style
+	 * @return
+	 *         the first found named style or <code>null</code>
+	 */
+	public NamedStyle getNamedStyle(final List<NamedStyle> namedStyles, final String name) {
+		if (namedStyles != null && name != null) {
+			return namedStyles.stream().filter(ns -> name.equals(ns.getName())).findFirst().orElse(null);
+		}
+		return null;
+	}
+
+
+}
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/build.properties b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/build.properties
new file mode 100755
index 0000000..9a0a3cf
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/build.properties
@@ -0,0 +1,24 @@
+# Copyright (c) 2020 CEA LIST.
+# 
+#  All rights reserved. This program and the accompanying materials
+#  are made available under the terms of the Eclipse Public License 2.0
+#  which accompanies this distribution, and is available at
+#  https://www.eclipse.org/legal/epl-2.0/
+# 
+#  SPDX-License-Identifier: EPL-2.0
+# 
+#  Contributors:
+#  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+
+bin.includes = .,\
+               model/,\
+               META-INF/,\
+               plugin.xml,\
+               plugin.properties,\
+               about.html,\
+               icons/
+jars.compile.order = .
+source.. = src-gen/,\
+           api/
+output.. = bin/
+src.includes = about.html
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/icons/Styles.gif b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/icons/Styles.gif
new file mode 100755
index 0000000..e886709
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/icons/Styles.gif
Binary files differ
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.di b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.di
new file mode 100755
index 0000000..8c549ee
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.di
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<architecture:ArchitectureDescription xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:architecture="http://www.eclipse.org/papyrus/infra/core/architecture" contextId="org.eclipse.papyrus.infra.services.edit.TypeContext"/>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.ecore b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.ecore
new file mode 100755
index 0000000..fca1fbe
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.ecore
@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="styles" nsURI="http://www.eclipse.org/papyrus/model2doc/core/1.0.0/Styles"
+    nsPrefix="styles">
+  <eAnnotations source="http://www.eclipse.org/uml2/2.0.0/UML">
+    <details key="originalName" value="Styles"/>
+  </eAnnotations>
+  <eClassifiers xsi:type="ecore:EClass" name="NamedStyle" abstract="true" interface="true">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" ordered="false" lowerBound="1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IntNamedStyle" eSuperTypes="#//NamedStyle">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="NamedStyle with an int as value"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" ordered="false"
+        lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="StringNamedStyle" eSuperTypes="#//NamedStyle">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="NamedStyle with a string as value"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" ordered="false"
+        lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="BooleanNamedStyle" eSuperTypes="#//NamedStyle">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="NamedStyle with a boolean as value"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" ordered="false"
+        lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="DoubleNamedStyle" eSuperTypes="#//NamedStyle">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="NamedStyle with a double as value"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" ordered="false"
+        lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDouble"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IntListNamedStyle" eSuperTypes="#//NamedStyle">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="NamedStyle with a list of int as value"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="values" ordered="false"
+        upperBound="-1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="StringListNamedStyle" eSuperTypes="#//NamedStyle">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="NamedStyle with a list of string as value"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="values" ordered="false"
+        upperBound="-1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="BooleanListNamedStyle" eSuperTypes="#//NamedStyle">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="NamedStyle with a list of boolean as value"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="values" ordered="false"
+        upperBound="-1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="DoubleListNamedStyle" eSuperTypes="#//NamedStyle">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="NamedStyle with a list of double as value"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="values" ordered="false"
+        upperBound="-1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDouble"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="StyledElement" abstract="true" interface="true">
+    <eOperations name="getNamedStyle" ordered="false" lowerBound="1" eType="#//NamedStyle">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="This method return the NamedStyle corresponding to the given name"/>
+        <details key="body" value="return org.eclipse.papyrus.model2doc.core.styles.NamedStyleOperations.INSTANCE.getNamedStyle(getNamedStyles(), name);"/>
+      </eAnnotations>
+      <eParameters name="name" ordered="false" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="namedStyles" ordered="false"
+        upperBound="-1" eType="#//NamedStyle" containment="true"/>
+  </eClassifiers>
+</ecore:EPackage>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.genmodel b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.genmodel
new file mode 100755
index 0000000..942d2ca
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.genmodel
@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:genmodel="http://www.eclipse.org/uml2/2.2.0/GenModel"
+    copyrightText="Copyright (c) 2020 CEA LIST.&#xA;&#xA; All rights reserved. This program and the accompanying materials&#xA; are made available under the terms of the Eclipse Public License 2.0&#xA; which accompanies this distribution, and is available at&#xA; https://www.eclipse.org/legal/epl-2.0/&#xA;&#xA; SPDX-License-Identifier: EPL-2.0&#xA;&#xA; Contributors:&#xA; Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation"
+    modelDirectory="/org.eclipse.papyrus.model2doc.core.styles/src-gen" creationIcons="false"
+    editDirectory="/org.eclipse.papyrus.model2doc.core.styles.edit/src-gen" editorDirectory="/org.eclipse.papyrus.model2doc.core.styles.editor/src-gen"
+    modelPluginID="org.eclipse.papyrus.model2doc.core.styles" modelName="Styles" nonNLSMarkers="true"
+    rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container" codeFormatting="true"
+    commentFormatting="true" testsDirectory="/org.eclipse.papyrus.model2doc.core.styles.tests/src-gen"
+    importerID="org.eclipse.uml2.uml.ecore.importer" complianceLevel="5.0" copyrightFields="false"
+    operationReflection="true" importOrganizing="true" cleanup="true" oSGiCompatible="true"
+    pluralizedGetters="true">
+  <genAnnotations source="http://www.eclipse.org/emf/2002/GenModel/importer/org.eclipse.uml2.uml.ecore.importer">
+    <details key="OPPOSITE_ROLE_NAMES" value="IGNORE"/>
+    <details key="DUPLICATE_FEATURES" value="DISCARD"/>
+    <details key="ANNOTATION_DETAILS" value="PROCESS"/>
+    <details key="PROPERTY_DEFAULT_EXPRESSIONS" value="IGNORE"/>
+    <details key="DUPLICATE_FEATURE_INHERITANCE" value="DISCARD"/>
+    <details key="COMMENTS" value="PROCESS"/>
+    <details key="DERIVED_FEATURES" value="PROCESS"/>
+    <details key="SUPER_CLASS_ORDER" value="PROCESS"/>
+    <details key="DUPLICATE_OPERATION_INHERITANCE" value="DISCARD"/>
+    <details key="REDEFINING_OPERATIONS" value="REPORT"/>
+    <details key="INVARIANT_CONSTRAINTS" value="PROCESS"/>
+    <details key="UNION_PROPERTIES" value="REPORT"/>
+    <details key="DUPLICATE_OPERATIONS" value="DISCARD"/>
+    <details key="NON_API_INVARIANTS" value="IGNORE"/>
+    <details key="CAMEL_CASE_NAMES" value="IGNORE"/>
+    <details key="SUBSETTING_PROPERTIES" value="REPORT"/>
+    <details key="OPERATION_BODIES" value="IGNORE"/>
+    <details key="ECORE_TAGGED_VALUES" value="PROCESS"/>
+    <details key="UNTYPED_PROPERTIES" value="REPORT"/>
+    <details key="REDEFINING_PROPERTIES" value="REPORT"/>
+    <details key="INVOCATION_DELEGATES" value="IGNORE"/>
+    <details key="VALIDATION_DELEGATES" value="IGNORE"/>
+  </genAnnotations>
+  <foreignModel>Styles.uml</foreignModel>
+  <genPackages xsi:type="genmodel:GenPackage" prefix="Styles" basePackage="org.eclipse.papyrus.model2doc.core"
+      disposableProviderFactory="true" ecorePackage="Styles.ecore#/">
+    <genClasses xsi:type="genmodel:GenClass" image="false" ecoreClass="Styles.ecore#//NamedStyle">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute Styles.ecore#//NamedStyle/name"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="Styles.ecore#//IntNamedStyle">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute Styles.ecore#//IntNamedStyle/value"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="Styles.ecore#//StringNamedStyle">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute Styles.ecore#//StringNamedStyle/value"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="Styles.ecore#//BooleanNamedStyle">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute Styles.ecore#//BooleanNamedStyle/value"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="Styles.ecore#//DoubleNamedStyle">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute Styles.ecore#//DoubleNamedStyle/value"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="Styles.ecore#//IntListNamedStyle">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute Styles.ecore#//IntListNamedStyle/values"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="Styles.ecore#//StringListNamedStyle">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute Styles.ecore#//StringListNamedStyle/values"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="Styles.ecore#//BooleanListNamedStyle">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute Styles.ecore#//BooleanListNamedStyle/values"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="Styles.ecore#//DoubleListNamedStyle">
+      <genFeatures xsi:type="genmodel:GenFeature" createChild="false" ecoreFeature="ecore:EAttribute Styles.ecore#//DoubleListNamedStyle/values"/>
+    </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" image="false" ecoreClass="Styles.ecore#//StyledElement">
+      <genFeatures xsi:type="genmodel:GenFeature" property="None" children="true"
+          createChild="true" ecoreFeature="ecore:EReference Styles.ecore#//StyledElement/namedStyles"/>
+      <genOperations xsi:type="genmodel:GenOperation" ecoreOperation="Styles.ecore#//StyledElement/getNamedStyle"
+          body="return org.eclipse.papyrus.model2doc.core.styles.NamedStyleOperations.INSTANCE.getNamedStyle(getNamedStyles(), name);">
+        <genParameters xsi:type="genmodel:GenParameter" ecoreParameter="Styles.ecore#//StyledElement/getNamedStyle/name"/>
+      </genOperations>
+    </genClasses>
+  </genPackages>
+</genmodel:GenModel>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.notation b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.notation
new file mode 100755
index 0000000..f118380
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.notation
@@ -0,0 +1,434 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xmi:XMI xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:css="http://www.eclipse.org/papyrus/infra/gmfdiag/css" xmlns:notation="http://www.eclipse.org/gmf/runtime/1.0.3/notation" xmlns:style="http://www.eclipse.org/papyrus/infra/gmfdiag/style" xmlns:uml="http://www.eclipse.org/uml2/5.0.0/UML">
+  <notation:Diagram xmi:id="_tBVJAC5PEeud9Ihhf94UEg" type="PapyrusUMLClassDiagram" name="Class Diagram" measurementUnit="Pixel">
+    <children xmi:type="notation:Shape" xmi:id="_fJqZIC5QEeud9Ihhf94UEg" type="Interface_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_fJrAMC5QEeud9Ihhf94UEg" type="Interface_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_fJrAMS5QEeud9Ihhf94UEg" type="Interface_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_fJrAMi5QEeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_fJrAMy5QEeud9Ihhf94UEg" type="Interface_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_187VkC5QEeud9Ihhf94UEg" type="Property_InterfaceAttributeLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Property" href="Styles.uml#_18ssEC5QEeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_187VkS5QEeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_fJrANC5QEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_fJrANS5QEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_fJrANi5QEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_fJrANy5QEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_fJrAOC5QEeud9Ihhf94UEg" type="Interface_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_fJrAOS5QEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_fJrAOi5QEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_fJrAOy5QEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_fJrAPC5QEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_fJrAPS5QEeud9Ihhf94UEg" type="Interface_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_fJrAPi5QEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_fJrAPy5QEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_fJrAQC5QEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_fJrAQS5QEeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Interface" href="Styles.uml#_fJpLAC5QEeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_fJqZIS5QEeud9Ihhf94UEg" x="720" y="60" width="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_F7XvQC5REeud9Ihhf94UEg" type="Class_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_F7XvQi5REeud9Ihhf94UEg" type="Class_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_F7XvQy5REeud9Ihhf94UEg" type="Class_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_F7XvRC5REeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_F7XvRS5REeud9Ihhf94UEg" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_zb8QcC5ZEeud9Ihhf94UEg" type="Property_ClassAttributeLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Property" href="Styles.uml#_6nitwC5UEeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_zb8QcS5ZEeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_F7XvRi5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_F7XvRy5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_F7XvSC5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_F7XvSS5REeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_F7XvSi5REeud9Ihhf94UEg" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_F7XvSy5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_F7XvTC5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_F7XvTS5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_F7XvTi5REeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_F7XvTy5REeud9Ihhf94UEg" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_F7XvUC5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_F7XvUS5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_F7XvUi5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_F7XvUy5REeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Class" href="Styles.uml#_F7Ur8C5REeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_F7XvQS5REeud9Ihhf94UEg" x="80" y="320" width="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_WqgmEC5REeud9Ihhf94UEg" type="Class_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_WqhNIC5REeud9Ihhf94UEg" type="Class_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_WqhNIS5REeud9Ihhf94UEg" type="Class_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_WqhNIi5REeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_WqhNIy5REeud9Ihhf94UEg" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_cLQ44C5REeud9Ihhf94UEg" type="Property_ClassAttributeLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Property" href="Styles.uml#_WqfX8S5REeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_cLQ44S5REeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_WqhNJC5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_WqhNJS5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_WqhNJi5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WqhNJy5REeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_WqhNKC5REeud9Ihhf94UEg" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_WqhNKS5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_WqhNKi5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_WqhNKy5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WqhNLC5REeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_WqhNLS5REeud9Ihhf94UEg" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_WqhNLi5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_WqhNLy5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_WqhNMC5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WqhNMS5REeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Class" href="Styles.uml#_WqfX8C5REeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_WqgmES5REeud9Ihhf94UEg" x="440" y="320" width="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_dOB9cC5REeud9Ihhf94UEg" type="Class_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_dOCkgC5REeud9Ihhf94UEg" type="Class_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_dOCkgS5REeud9Ihhf94UEg" type="Class_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_dOCkgi5REeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_dOCkgy5REeud9Ihhf94UEg" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_tNx-sC5REeud9Ihhf94UEg" type="Property_ClassAttributeLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Property" href="Styles.uml#_dOAIQC5REeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_tNx-sS5REeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_dOCkhC5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_dOCkhS5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_dOCkhi5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dOCkhy5REeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_dOCkiC5REeud9Ihhf94UEg" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_dOCkiS5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_dOCkii5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_dOCkiy5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dOCkjC5REeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_dOCkjS5REeud9Ihhf94UEg" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_dOCkji5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_dOCkjy5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_dOCkkC5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dOCkkS5REeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Class" href="Styles.uml#_dN_hMC5REeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_dOB9cS5REeud9Ihhf94UEg" x="800" y="320" width="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_pAHrcC5REeud9Ihhf94UEg" type="Class_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_pAISgC5REeud9Ihhf94UEg" type="Class_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_pAISgS5REeud9Ihhf94UEg" type="Class_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_pAISgi5REeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_pAI5kC5REeud9Ihhf94UEg" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_tqTioC5REeud9Ihhf94UEg" type="Property_ClassAttributeLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Property" href="Styles.uml#_pAF2QS5REeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_tqTioS5REeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_pAI5kS5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_pAI5ki5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_pAI5ky5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_pAI5lC5REeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_pAI5lS5REeud9Ihhf94UEg" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_pAI5li5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_pAI5ly5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_pAI5mC5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_pAI5mS5REeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_pAI5mi5REeud9Ihhf94UEg" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_pAI5my5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_pAI5nC5REeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_pAI5nS5REeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_pAI5ni5REeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Class" href="Styles.uml#_pAF2QC5REeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_pAHrcS5REeud9Ihhf94UEg" x="1140" y="320" width="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_Sf6_gC5SEeud9Ihhf94UEg" type="Class_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_Sf7mkC5SEeud9Ihhf94UEg" type="Class_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_Sf7mkS5SEeud9Ihhf94UEg" type="Class_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_Sf7mki5SEeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Sf7mky5SEeud9Ihhf94UEg" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_V9cPQC5SEeud9Ihhf94UEg" type="Property_ClassAttributeLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Property" href="Styles.uml#_Sf5xYi5SEeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_V9cPQS5SEeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Sf7mlC5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Sf7mlS5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Sf7mli5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Sf7mly5SEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Sf7mmC5SEeud9Ihhf94UEg" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Sf7mmS5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Sf7mmi5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Sf7mmy5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Sf7mnC5SEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_Sf7mnS5SEeud9Ihhf94UEg" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_Sf7mni5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_Sf7mny5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_Sf7moC5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Sf7moS5SEeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Class" href="Styles.uml#_Sf5xYC5SEeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_Sf6_gS5SEeud9Ihhf94UEg" x="260" y="460" width="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_cefhcC5SEeud9Ihhf94UEg" type="Class_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_cefhci5SEeud9Ihhf94UEg" type="Class_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cefhcy5SEeud9Ihhf94UEg" type="Class_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cefhdC5SEeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cefhdS5SEeud9Ihhf94UEg" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_dLJMEC5SEeud9Ihhf94UEg" type="Property_ClassAttributeLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Property" href="Styles.uml#_Y9QPUi5SEeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_dLJzIC5SEeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cefhdi5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cefhdy5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cefheC5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cefheS5SEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cefhei5SEeud9Ihhf94UEg" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cefhey5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cefhfC5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cefhfS5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cefhfi5SEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cefhfy5SEeud9Ihhf94UEg" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cefhgC5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cefhgS5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cefhgi5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cefhgy5SEeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Class" href="Styles.uml#_Y9QPUC5SEeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cefhcS5SEeud9Ihhf94UEg" x="620" y="460" width="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_hnEk0C5SEeud9Ihhf94UEg" type="Class_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_hnFy8C5SEeud9Ihhf94UEg" type="Class_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_hnFy8S5SEeud9Ihhf94UEg" type="Class_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_hnFy8i5SEeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hnFy8y5SEeud9Ihhf94UEg" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_k2K-EC5SEeud9Ihhf94UEg" type="Property_ClassAttributeLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Property" href="Styles.uml#_ZArWwi5SEeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_k2K-ES5SEeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hnFy9C5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hnFy9S5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hnFy9i5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hnFy9y5SEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hnGaAC5SEeud9Ihhf94UEg" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hnGaAS5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hnGaAi5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hnGaAy5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hnGaBC5SEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_hnGaBS5SEeud9Ihhf94UEg" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_hnGaBi5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_hnGaBy5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_hnGaCC5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hnGaCS5SEeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Class" href="Styles.uml#_ZArWwC5SEeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_hnEk0S5SEeud9Ihhf94UEg" x="960" y="460" width="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_nyiBgC5SEeud9Ihhf94UEg" type="Class_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_nyiokC5SEeud9Ihhf94UEg" type="Class_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_nyiokS5SEeud9Ihhf94UEg" type="Class_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_nyioki5SEeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_nyioky5SEeud9Ihhf94UEg" type="Class_AttributeCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_qJ8k0C5SEeud9Ihhf94UEg" type="Property_ClassAttributeLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Property" href="Styles.uml#_ZTzuIi5SEeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_qJ8k0S5SEeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_nyiolC5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_nyiolS5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_nyioli5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nyioly5SEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_nyiomC5SEeud9Ihhf94UEg" type="Class_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_nyiomS5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_nyiomi5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_nyiomy5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nyionC5SEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_nyionS5SEeud9Ihhf94UEg" type="Class_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_nyioni5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_nyiony5SEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_nyiooC5SEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nyiooS5SEeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Class" href="Styles.uml#_ZTzuIC5SEeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_nyiBgS5SEeud9Ihhf94UEg" x="1320" y="460" width="161"/>
+    </children>
+    <children xmi:type="notation:Shape" xmi:id="_cPDTEC5ZEeud9Ihhf94UEg" type="Interface_Shape" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_cPDTEi5ZEeud9Ihhf94UEg" type="Interface_NameLabel"/>
+      <children xmi:type="notation:DecorationNode" xmi:id="_cPDTEy5ZEeud9Ihhf94UEg" type="Interface_FloatingNameLabel">
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_cPDTFC5ZEeud9Ihhf94UEg" y="15"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cPD6IC5ZEeud9Ihhf94UEg" type="Interface_AttributeCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cPD6IS5ZEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cPD6Ii5ZEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cPD6Iy5ZEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cPD6JC5ZEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cPD6JS5ZEeud9Ihhf94UEg" type="Interface_OperationCompartment">
+        <children xmi:type="notation:Shape" xmi:id="_nOYucC5ZEeud9Ihhf94UEg" type="Operation_InterfaceOperationLabel" fontName="Segoe UI" fillColor="14012867" transparency="0" gradient="16777215, -1, 0" lineColor="0">
+          <element xmi:type="uml:Operation" href="Styles.uml#_kxSZ4C5ZEeud9Ihhf94UEg"/>
+          <layoutConstraint xmi:type="notation:Location" xmi:id="_nOYucS5ZEeud9Ihhf94UEg"/>
+        </children>
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cPD6Ji5ZEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cPD6Jy5ZEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cPD6KC5ZEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cPD6KS5ZEeud9Ihhf94UEg"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_cPD6Ki5ZEeud9Ihhf94UEg" type="Interface_NestedClassifierCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_cPD6Ky5ZEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_cPD6LC5ZEeud9Ihhf94UEg"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_cPD6LS5ZEeud9Ihhf94UEg"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cPD6Li5ZEeud9Ihhf94UEg"/>
+      </children>
+      <element xmi:type="uml:Interface" href="Styles.uml#_cPAPwC5ZEeud9Ihhf94UEg"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_cPDTES5ZEeud9Ihhf94UEg" x="220" y="60" width="301"/>
+    </children>
+    <styles xmi:type="notation:StringValueStyle" xmi:id="_tBVJAS5PEeud9Ihhf94UEg" name="diagram_compatibility_version" stringValue="1.4.0"/>
+    <styles xmi:type="notation:DiagramStyle" xmi:id="_tBVJAi5PEeud9Ihhf94UEg"/>
+    <styles xmi:type="style:PapyrusDiagramStyle" xmi:id="_tBVJAy5PEeud9Ihhf94UEg" diagramKindId="org.eclipse.papyrus.uml.diagram.class">
+      <owner xmi:type="uml:Model" href="Styles.uml#_tASnMC5PEeud9Ihhf94UEg"/>
+    </styles>
+    <styles xmi:type="notation:EObjectListValueStyle" xmi:id="__f8N0C5ZEeud9Ihhf94UEg" name="css_stylesheets"/>
+    <element xmi:type="uml:Model" href="Styles.uml#_tASnMC5PEeud9Ihhf94UEg"/>
+    <edges xmi:type="notation:Connector" xmi:id="_zGb0IC5REeud9Ihhf94UEg" type="Generalization_Edge" source="_F7XvQC5REeud9Ihhf94UEg" target="_fJqZIC5QEeud9Ihhf94UEg" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_zGcbMC5REeud9Ihhf94UEg" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_3eCtkC5REeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_zGcbMS5REeud9Ihhf94UEg" y="39"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_zGb0IS5REeud9Ihhf94UEg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="Styles.uml#_zGLVcC5REeud9Ihhf94UEg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_zGb0Ii5REeud9Ihhf94UEg" points="[160, 320, -643984, -643984]$[160, 260, -643984, -643984]$[800, 260, -643984, -643984]$[800, 171, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_zG6VQC5REeud9Ihhf94UEg" id="(0.4968944099378882,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_zG6VQS5REeud9Ihhf94UEg" id="(0.4968944099378882,1.0)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_zasM4C5REeud9Ihhf94UEg" type="Generalization_Edge" source="_WqgmEC5REeud9Ihhf94UEg" target="_fJqZIC5QEeud9Ihhf94UEg" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_zasM4y5REeud9Ihhf94UEg" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_3eO60C5REeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_zasM5C5REeud9Ihhf94UEg" x="-1" y="38"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_zasM4S5REeud9Ihhf94UEg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="Styles.uml#_zaZ5AC5REeud9Ihhf94UEg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_zasM4i5REeud9Ihhf94UEg" points="[520, 320, -643984, -643984]$[520, 260, -643984, -643984]$[800, 260, -643984, -643984]$[800, 171, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_zbOYYC5REeud9Ihhf94UEg" id="(0.4968944099378882,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_zbOYYS5REeud9Ihhf94UEg" id="(0.4968944099378882,1.0)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_zvJZ8C5REeud9Ihhf94UEg" type="Generalization_Edge" source="_dOB9cC5REeud9Ihhf94UEg" target="_fJqZIC5QEeud9Ihhf94UEg" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_zvJZ8y5REeud9Ihhf94UEg" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_3ebIEC5REeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_zvKBAC5REeud9Ihhf94UEg" x="-1" y="38"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_zvJZ8S5REeud9Ihhf94UEg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="Styles.uml#_zu7XgC5REeud9Ihhf94UEg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_zvJZ8i5REeud9Ihhf94UEg" points="[880, 320, -643984, -643984]$[880, 260, -643984, -643984]$[800, 260, -643984, -643984]$[800, 171, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_zvoiIC5REeud9Ihhf94UEg" id="(0.4968944099378882,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_zvpJMC5REeud9Ihhf94UEg" id="(0.4968944099378882,1.0)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_0RG3gC5REeud9Ihhf94UEg" type="Generalization_Edge" source="_pAHrcC5REeud9Ihhf94UEg" target="_fJqZIC5QEeud9Ihhf94UEg" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_0RG3gy5REeud9Ihhf94UEg" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_3epKgC5REeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_0RG3hC5REeud9Ihhf94UEg" x="-1" y="38"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_0RG3gS5REeud9Ihhf94UEg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="Styles.uml#_0Q3m8C5REeud9Ihhf94UEg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_0RG3gi5REeud9Ihhf94UEg" points="[1200, 320, -643984, -643984]$[1220, 260, -643984, -643984]$[800, 260, -643984, -643984]$[800, 171, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_0Rob8C5REeud9Ihhf94UEg" id="(0.4968944099378882,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_0Rob8S5REeud9Ihhf94UEg" id="(0.4968944099378882,1.0)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_79uvgC5SEeud9Ihhf94UEg" type="Generalization_Edge" source="_nyiBgC5SEeud9Ihhf94UEg" target="_fJqZIC5QEeud9Ihhf94UEg" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_79uvgy5SEeud9Ihhf94UEg" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_D0TqMC5TEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_79uvhC5SEeud9Ihhf94UEg" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_79uvgS5SEeud9Ihhf94UEg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="Styles.uml#_ZTzuIS5SEeud9Ihhf94UEg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_79uvgi5SEeud9Ihhf94UEg" points="[1400, 480, -643984, -643984]$[1400, 260, -643984, -643984]$[800, 260, -643984, -643984]$[881, 120, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_AccWgC5TEeud9Ihhf94UEg" id="(0.4968944099378882,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Dz7PsC5TEeud9Ihhf94UEg" id="(0.4968944099378882,1.0)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_8TtmkC5SEeud9Ihhf94UEg" type="Generalization_Edge" source="_hnEk0C5SEeud9Ihhf94UEg" target="_fJqZIC5QEeud9Ihhf94UEg" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_8TuNoC5SEeud9Ihhf94UEg" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_K0JKIC5TEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_8TuNoS5SEeud9Ihhf94UEg" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_8TtmkS5SEeud9Ihhf94UEg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="Styles.uml#_ZArWwS5SEeud9Ihhf94UEg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_8Ttmki5SEeud9Ihhf94UEg" points="[1040, 480, -643984, -643984]$[1040, 260, -643984, -643984]$[800, 260, -643984, -643984]$[881, 160, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_AbsIkC5TEeud9Ihhf94UEg" id="(0.4968944099378882,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_Kz0aAC5TEeud9Ihhf94UEg" id="(0.4968944099378882,1.0)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_8iBIUC5SEeud9Ihhf94UEg" type="Generalization_Edge" source="_cefhcC5SEeud9Ihhf94UEg" target="_fJqZIC5QEeud9Ihhf94UEg" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_8iBIUy5SEeud9Ihhf94UEg" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_JSlQwC5TEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_8iBIVC5SEeud9Ihhf94UEg" y="40"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_8iBIUS5SEeud9Ihhf94UEg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="Styles.uml#_Y9QPUS5SEeud9Ihhf94UEg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_8iBIUi5SEeud9Ihhf94UEg" points="[700, 460, -643984, -643984]$[700, 260, -643984, -643984]$[800, 260, -643984, -643984]$[760, 171, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_AcEjEC5TEeud9Ihhf94UEg" id="(0.4968944099378882,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_JSRHsC5TEeud9Ihhf94UEg" id="(0.4968944099378882,1.0)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_8yPVoC5SEeud9Ihhf94UEg" type="Generalization_Edge" source="_Sf6_gC5SEeud9Ihhf94UEg" target="_fJqZIC5QEeud9Ihhf94UEg" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_8yPVoy5SEeud9Ihhf94UEg" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_G8gxQC5TEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_8yPVpC5SEeud9Ihhf94UEg" y="39"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_8yPVoS5SEeud9Ihhf94UEg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Generalization" href="Styles.uml#_Sf5xYS5SEeud9Ihhf94UEg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_8yPVoi5SEeud9Ihhf94UEg" points="[340, 460, -643984, -643984]$[340, 260, -643984, -643984]$[800, 260, -643984, -643984]$[800, 171, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_-m04sC5SEeud9Ihhf94UEg" id="(0.4968944099378882,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_G8I90C5TEeud9Ihhf94UEg" id="(0.4968944099378882,1.0)"/>
+    </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_RPhnQC5VEeud9Ihhf94UEg" type="Association_Edge" source="_cPDTEC5ZEeud9Ihhf94UEg" target="_fJqZIC5QEeud9Ihhf94UEg" routing="Rectilinear" lineColor="0">
+      <children xmi:type="notation:DecorationNode" xmi:id="_RPhnQy5VEeud9Ihhf94UEg" type="Association_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_noWDYC5VEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_RPhnRC5VEeud9Ihhf94UEg" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_RPhnRS5VEeud9Ihhf94UEg" visible="false" type="Association_NameLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_noxhMC5VEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_RPhnRi5VEeud9Ihhf94UEg" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_RPhnRy5VEeud9Ihhf94UEg" visible="false" type="Association_TargetRoleLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_npJUoC5VEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_RPhnSC5VEeud9Ihhf94UEg" x="20" y="-20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_RPhnSS5VEeud9Ihhf94UEg" type="Association_SourceRoleLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_nphvIC5VEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_RPhnSi5VEeud9Ihhf94UEg" x="-22" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_RPhnSy5VEeud9Ihhf94UEg" visible="false" type="Association_SourceMultiplicityLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_np90AC5VEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_RPhnTC5VEeud9Ihhf94UEg" x="20" y="20"/>
+      </children>
+      <children xmi:type="notation:DecorationNode" xmi:id="_RPhnTS5VEeud9Ihhf94UEg" type="Association_TargetMultiplicityLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_nqXcoC5VEeud9Ihhf94UEg" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_RPhnTi5VEeud9Ihhf94UEg" x="-22" y="-20"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_RPhnQS5VEeud9Ihhf94UEg" fontName="Segoe UI"/>
+      <element xmi:type="uml:Association" href="Styles.uml#_ROwyQC5VEeud9Ihhf94UEg"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_RPhnQi5VEeud9Ihhf94UEg" points="[426, 100, -643984, -643984]$[720, 100, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_RQa_IC5VEeud9Ihhf94UEg" id="(1.0,0.36036036036036034)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_RQa_IS5VEeud9Ihhf94UEg" id="(0.0,0.36036036036036034)"/>
+    </edges>
+  </notation:Diagram>
+  <css:ModelStyleSheets xmi:id="_PhFWMC5aEeud9Ihhf94UEg">
+    <stylesheets xmi:type="css:StyleSheetReference" xmi:id="__f38YC5ZEeud9Ihhf94UEg" path="/org.eclipse.papyrus.model2doc.core.builtintypes/model/custom.css"/>
+  </css:ModelStyleSheets>
+</xmi:XMI>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.uml b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.uml
new file mode 100755
index 0000000..ab125dd
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/model/Styles.uml
@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xmi:XMI xmi:version="20131001" xmlns:xmi="http://www.omg.org/spec/XMI/20131001" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:Ecore="http://www.eclipse.org/uml2/schemas/Ecore/5" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:uml="http://www.eclipse.org/uml2/5.0.0/UML" xsi:schemaLocation="http://www.eclipse.org/uml2/schemas/Ecore/5 pathmap://UML_PROFILES/Ecore.profile.uml#_z1OFcHjqEdy8S4Cr8Rc_NA">
+  <uml:Model xmi:id="_tASnMC5PEeud9Ihhf94UEg" name="Styles" URI="http://www.eclipse.org/papyrus/model2doc/core/1.0.0/Styles">
+    <packageImport xmi:type="uml:PackageImport" xmi:id="_tCiC4C5PEeud9Ihhf94UEg">
+      <importedPackage xmi:type="uml:Model" href="pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#_0"/>
+    </packageImport>
+    <packagedElement xmi:type="uml:Interface" xmi:id="_fJpLAC5QEeud9Ihhf94UEg" name="NamedStyle">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_18ssEC5QEeud9Ihhf94UEg" name="name">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EString"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_F7Ur8C5REeud9Ihhf94UEg" name="IntNamedStyle">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_90Fs0C5VEeud9Ihhf94UEg" annotatedElement="_F7Ur8C5REeud9Ihhf94UEg">
+        <body>NamedStyle with an int as value</body>
+      </ownedComment>
+      <generalization xmi:type="uml:Generalization" xmi:id="_zGLVcC5REeud9Ihhf94UEg" general="_fJpLAC5QEeud9Ihhf94UEg"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_6nitwC5UEeud9Ihhf94UEg" name="value">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EInt"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_WqfX8C5REeud9Ihhf94UEg" name="StringNamedStyle">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_FFe20C5WEeud9Ihhf94UEg" annotatedElement="_WqfX8C5REeud9Ihhf94UEg">
+        <body>NamedStyle with a string as value</body>
+      </ownedComment>
+      <generalization xmi:type="uml:Generalization" xmi:id="_zaZ5AC5REeud9Ihhf94UEg" general="_fJpLAC5QEeud9Ihhf94UEg"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_WqfX8S5REeud9Ihhf94UEg" name="value">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EString"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_dN_hMC5REeud9Ihhf94UEg" name="BooleanNamedStyle">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_Hj6BEC5WEeud9Ihhf94UEg" annotatedElement="_dN_hMC5REeud9Ihhf94UEg">
+        <body>NamedStyle with a boolean as value</body>
+      </ownedComment>
+      <generalization xmi:type="uml:Generalization" xmi:id="_zu7XgC5REeud9Ihhf94UEg" general="_fJpLAC5QEeud9Ihhf94UEg"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_dOAIQC5REeud9Ihhf94UEg" name="value">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EBoolean"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_pAF2QC5REeud9Ihhf94UEg" name="DoubleNamedStyle">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_JWoi8C5WEeud9Ihhf94UEg" annotatedElement="_pAF2QC5REeud9Ihhf94UEg">
+        <body>NamedStyle with a double as value</body>
+      </ownedComment>
+      <generalization xmi:type="uml:Generalization" xmi:id="_0Q3m8C5REeud9Ihhf94UEg" general="_fJpLAC5QEeud9Ihhf94UEg"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_pAF2QS5REeud9Ihhf94UEg" name="value">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EDouble"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_Sf5xYC5SEeud9Ihhf94UEg" name="IntListNamedStyle">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_LVKsMC5WEeud9Ihhf94UEg" annotatedElement="_Sf5xYC5SEeud9Ihhf94UEg">
+        <body>NamedStyle with a list of int as value</body>
+      </ownedComment>
+      <generalization xmi:type="uml:Generalization" xmi:id="_Sf5xYS5SEeud9Ihhf94UEg" general="_fJpLAC5QEeud9Ihhf94UEg"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_Sf5xYi5SEeud9Ihhf94UEg" name="values">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EInt"/>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_XLGVMC5SEeud9Ihhf94UEg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_XLdhkC5SEeud9Ihhf94UEg" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_Y9QPUC5SEeud9Ihhf94UEg" name="StringListNamedStyle">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_M7g-8C5WEeud9Ihhf94UEg" annotatedElement="_Y9QPUC5SEeud9Ihhf94UEg">
+        <body>NamedStyle with a list of string as value</body>
+      </ownedComment>
+      <generalization xmi:type="uml:Generalization" xmi:id="_Y9QPUS5SEeud9Ihhf94UEg" general="_fJpLAC5QEeud9Ihhf94UEg"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_Y9QPUi5SEeud9Ihhf94UEg" name="values">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EString"/>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_Y9QPUy5SEeud9Ihhf94UEg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_Y9QPVC5SEeud9Ihhf94UEg" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_ZArWwC5SEeud9Ihhf94UEg" name="BooleanListNamedStyle">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_Onib4C5WEeud9Ihhf94UEg" annotatedElement="_ZArWwC5SEeud9Ihhf94UEg">
+        <body>NamedStyle with a list of boolean as value</body>
+      </ownedComment>
+      <generalization xmi:type="uml:Generalization" xmi:id="_ZArWwS5SEeud9Ihhf94UEg" general="_fJpLAC5QEeud9Ihhf94UEg"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_ZArWwi5SEeud9Ihhf94UEg" name="values">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EBoolean"/>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_ZArWwy5SEeud9Ihhf94UEg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_ZArWxC5SEeud9Ihhf94UEg" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_ZTzuIC5SEeud9Ihhf94UEg" name="DoubleListNamedStyle">
+      <ownedComment xmi:type="uml:Comment" xmi:id="_QubP4C5WEeud9Ihhf94UEg" annotatedElement="_ZTzuIC5SEeud9Ihhf94UEg">
+        <body>NamedStyle with a list of double as value</body>
+      </ownedComment>
+      <generalization xmi:type="uml:Generalization" xmi:id="_ZTzuIS5SEeud9Ihhf94UEg" general="_fJpLAC5QEeud9Ihhf94UEg"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_ZTzuIi5SEeud9Ihhf94UEg" name="values">
+        <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EDouble"/>
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_ZTzuIy5SEeud9Ihhf94UEg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_ZTzuJC5SEeud9Ihhf94UEg" value="*"/>
+      </ownedAttribute>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Association" xmi:id="_ROwyQC5VEeud9Ihhf94UEg" memberEnd="_RO5VIC5VEeud9Ihhf94UEg _RPNeMC5VEeud9Ihhf94UEg">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_RO4HAC5VEeud9Ihhf94UEg" source="org.eclipse.papyrus">
+        <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_RO4uEC5VEeud9Ihhf94UEg" key="nature" value="UML_Nature"/>
+      </eAnnotations>
+      <ownedEnd xmi:type="uml:Property" xmi:id="_RPNeMC5VEeud9Ihhf94UEg" name="styledelement" type="_cPAPwC5ZEeud9Ihhf94UEg" association="_ROwyQC5VEeud9Ihhf94UEg"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Interface" xmi:id="_cPAPwC5ZEeud9Ihhf94UEg" name="StyledElement">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_RO5VIC5VEeud9Ihhf94UEg" name="namedStyles" type="_fJpLAC5QEeud9Ihhf94UEg" aggregation="composite" association="_ROwyQC5VEeud9Ihhf94UEg">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_RO9mkC5VEeud9Ihhf94UEg"/>
+        <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_RPE7UC5VEeud9Ihhf94UEg" value="*"/>
+      </ownedAttribute>
+      <ownedOperation xmi:type="uml:Operation" xmi:id="_kxSZ4C5ZEeud9Ihhf94UEg" name="getNamedStyle">
+        <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_kxSZ4S5ZEeud9Ihhf94UEg" source="http://www.eclipse.org/emf/2002/GenModel">
+          <details xmi:type="ecore:EStringToStringMapEntry" xmi:id="_kxSZ4i5ZEeud9Ihhf94UEg" key="body" value="return org.eclipse.papyrus.model2doc.core.styles.internal.operations.NamedStyleOperations.INSTANCE.getNamedStyle(getNamedStyles(), name);"/>
+        </eAnnotations>
+        <ownedComment xmi:type="uml:Comment" xmi:id="_kxSZ4y5ZEeud9Ihhf94UEg" annotatedElement="_kxSZ4C5ZEeud9Ihhf94UEg">
+          <body>This method return the NamedStyle corresponding to the given name</body>
+        </ownedComment>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_kxSZ5C5ZEeud9Ihhf94UEg" name="ret" type="_fJpLAC5QEeud9Ihhf94UEg" direction="return"/>
+        <ownedParameter xmi:type="uml:Parameter" xmi:id="_kxSZ5S5ZEeud9Ihhf94UEg" name="name">
+          <type xmi:type="uml:PrimitiveType" href="pathmap://UML_LIBRARIES/EcorePrimitiveTypes.library.uml#EString"/>
+        </ownedParameter>
+      </ownedOperation>
+    </packagedElement>
+    <profileApplication xmi:type="uml:ProfileApplication" xmi:id="_A9CpgC5QEeud9Ihhf94UEg">
+      <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_A9Fs0C5QEeud9Ihhf94UEg" source="http://www.eclipse.org/uml2/2.0.0/UML">
+        <references xmi:type="ecore:EPackage" href="pathmap://UML_PROFILES/Ecore.profile.uml#_z1OFcHjqEdy8S4Cr8Rc_NA"/>
+      </eAnnotations>
+      <appliedProfile xmi:type="uml:Profile" href="pathmap://UML_PROFILES/Ecore.profile.uml#_0"/>
+    </profileApplication>
+  </uml:Model>
+  <Ecore:EPackage xmi:id="_BhHm8C5QEeud9Ihhf94UEg" base_Package="_tASnMC5PEeud9Ihhf94UEg" packageName="styles" nsPrefix="styles" basePackage="org.eclipse.papyrus.model2doc.core" prefix="Styles"/>
+</xmi:XMI>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/plugin.properties b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/plugin.properties
new file mode 100755
index 0000000..5b69c41
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/plugin.properties
@@ -0,0 +1,16 @@
+# Copyright (c) 2020 CEA LIST.
+# 
+#  All rights reserved. This program and the accompanying materials
+#  are made available under the terms of the Eclipse Public License 2.0
+#  which accompanies this distribution, and is available at
+#  https://www.eclipse.org/legal/epl-2.0/
+# 
+#  SPDX-License-Identifier: EPL-2.0
+# 
+#  Contributors:
+#  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+
+Bundle-Vendor = Eclipse Modeling Project
+Bundle-Name = Papyrus-Model2Doc - Core Styles (Incubation)
+pluginName = Papyrus-Model2Doc - Core Styles (Incubation)
+providerName = Eclipse Modeling Project
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/plugin.xml b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/plugin.xml
new file mode 100755
index 0000000..85eee1c
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/plugin.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<!--
+ Copyright (c) 2020 CEA LIST.
+ 
+  All rights reserved. This program and the accompanying materials
+  are made available under the terms of the Eclipse Public License 2.0
+  which accompanies this distribution, and is available at
+  https://www.eclipse.org/legal/epl-2.0/
+ 
+  SPDX-License-Identifier: EPL-2.0
+ 
+  Contributors:
+  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+-->
+
+<plugin>
+
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated Styles -->
+      <package
+            uri="http://www.eclipse.org/papyrus/model2doc/core/1.0.0/Styles"
+            class="org.eclipse.papyrus.model2doc.core.styles.StylesPackage"
+            genModel="model/Styles.genmodel"/>
+   </extension>
+   <extension
+         point="org.eclipse.emf.ecore.uri_mapping">
+      <mapping
+            source="pathmap://MODEL2DOC/STYLES/"
+            target="platform:/plugin/org.eclipse.papyrus.model2doc.core.styles/model/">
+      </mapping>
+   </extension>
+   <extension
+         point="org.eclipse.papyrus.uml.extensionpoints.UMLLibrary">
+      <library
+            description="The Papyrus-Model2Doc Core Styles UML model"
+            iconpath="icons/Styles.gif"
+            name="Papyrus-Model2Doc - Core Styles (Internal)"
+            path="pathmap://MODEL2DOC/STYLES/Styles.uml">
+      </library>
+   </extension>
+
+</plugin>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/pom.xml b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/pom.xml
new file mode 100755
index 0000000..8ad7e7c
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/pom.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<groupId>org.eclipse.papyrus.model2doc.plugins-core</groupId>
+		<artifactId>org.eclipse.papyrus.model2doc.plugins.core</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+
+	<artifactId>org.eclipse.papyrus.model2doc.core.styles</artifactId>
+	<version>0.8.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+
+</project>
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/BooleanListNamedStyle.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/BooleanListNamedStyle.java
new file mode 100755
index 0000000..6cb909b
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/BooleanListNamedStyle.java
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+import org.eclipse.emf.common.util.EList;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Boolean List Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <!-- begin-model-doc -->
+ * NamedStyle with a list of boolean as value
+ * <!-- end-model-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle#getValues <em>Values</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getBooleanListNamedStyle()
+ * @model
+ * @generated
+ */
+public interface BooleanListNamedStyle extends NamedStyle {
+	/**
+	 * Returns the value of the '<em><b>Values</b></em>' attribute list.
+	 * The list contents are of type {@link java.lang.Boolean}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Values</em>' attribute list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Values</em>' attribute list.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getBooleanListNamedStyle_Values()
+	 * @model ordered="false"
+	 * @generated
+	 */
+	EList<Boolean> getValues();
+
+} // BooleanListNamedStyle
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/BooleanNamedStyle.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/BooleanNamedStyle.java
new file mode 100755
index 0000000..3d41052
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/BooleanNamedStyle.java
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Boolean Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <!-- begin-model-doc -->
+ * NamedStyle with a boolean as value
+ * <!-- end-model-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle#isValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getBooleanNamedStyle()
+ * @model
+ * @generated
+ */
+public interface BooleanNamedStyle extends NamedStyle {
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(boolean)
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getBooleanNamedStyle_Value()
+	 * @model required="true" ordered="false"
+	 * @generated
+	 */
+	boolean isValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle#isValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @param value
+	 *            the new value of the '<em>Value</em>' attribute.
+	 * @see #isValue()
+	 * @generated
+	 */
+	void setValue(boolean value);
+
+} // BooleanNamedStyle
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/DoubleListNamedStyle.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/DoubleListNamedStyle.java
new file mode 100755
index 0000000..eac50c9
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/DoubleListNamedStyle.java
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+import org.eclipse.emf.common.util.EList;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Double List Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <!-- begin-model-doc -->
+ * NamedStyle with a list of double as value
+ * <!-- end-model-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle#getValues <em>Values</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getDoubleListNamedStyle()
+ * @model
+ * @generated
+ */
+public interface DoubleListNamedStyle extends NamedStyle {
+	/**
+	 * Returns the value of the '<em><b>Values</b></em>' attribute list.
+	 * The list contents are of type {@link java.lang.Double}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Values</em>' attribute list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Values</em>' attribute list.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getDoubleListNamedStyle_Values()
+	 * @model ordered="false"
+	 * @generated
+	 */
+	EList<Double> getValues();
+
+} // DoubleListNamedStyle
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/DoubleNamedStyle.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/DoubleNamedStyle.java
new file mode 100755
index 0000000..8994d85
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/DoubleNamedStyle.java
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Double Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <!-- begin-model-doc -->
+ * NamedStyle with a double as value
+ * <!-- end-model-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getDoubleNamedStyle()
+ * @model
+ * @generated
+ */
+public interface DoubleNamedStyle extends NamedStyle {
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(double)
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getDoubleNamedStyle_Value()
+	 * @model required="true" ordered="false"
+	 * @generated
+	 */
+	double getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @param value
+	 *            the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(double value);
+
+} // DoubleNamedStyle
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/IntListNamedStyle.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/IntListNamedStyle.java
new file mode 100755
index 0000000..8fdb7dc
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/IntListNamedStyle.java
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+import org.eclipse.emf.common.util.EList;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Int List Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <!-- begin-model-doc -->
+ * NamedStyle with a list of int as value
+ * <!-- end-model-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle#getValues <em>Values</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getIntListNamedStyle()
+ * @model
+ * @generated
+ */
+public interface IntListNamedStyle extends NamedStyle {
+	/**
+	 * Returns the value of the '<em><b>Values</b></em>' attribute list.
+	 * The list contents are of type {@link java.lang.Integer}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Values</em>' attribute list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Values</em>' attribute list.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getIntListNamedStyle_Values()
+	 * @model ordered="false"
+	 * @generated
+	 */
+	EList<Integer> getValues();
+
+} // IntListNamedStyle
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/IntNamedStyle.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/IntNamedStyle.java
new file mode 100755
index 0000000..e4b5eaf
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/IntNamedStyle.java
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Int Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <!-- begin-model-doc -->
+ * NamedStyle with an int as value
+ * <!-- end-model-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getIntNamedStyle()
+ * @model
+ * @generated
+ */
+public interface IntNamedStyle extends NamedStyle {
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(int)
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getIntNamedStyle_Value()
+	 * @model required="true" ordered="false"
+	 * @generated
+	 */
+	int getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @param value
+	 *            the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(int value);
+
+} // IntNamedStyle
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/NamedStyle.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/NamedStyle.java
new file mode 100755
index 0000000..84ddaf2
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/NamedStyle.java
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.NamedStyle#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getNamedStyle()
+ * @model interface="true" abstract="true"
+ * @generated
+ */
+public interface NamedStyle extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Name</em>' attribute.
+	 * @see #setName(String)
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getNamedStyle_Name()
+	 * @model required="true" ordered="false"
+	 * @generated
+	 */
+	String getName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.model2doc.core.styles.NamedStyle#getName <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @param value
+	 *            the new value of the '<em>Name</em>' attribute.
+	 * @see #getName()
+	 * @generated
+	 */
+	void setName(String value);
+
+} // NamedStyle
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StringListNamedStyle.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StringListNamedStyle.java
new file mode 100755
index 0000000..36e2f1e
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StringListNamedStyle.java
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+import org.eclipse.emf.common.util.EList;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>String List Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <!-- begin-model-doc -->
+ * NamedStyle with a list of string as value
+ * <!-- end-model-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle#getValues <em>Values</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getStringListNamedStyle()
+ * @model
+ * @generated
+ */
+public interface StringListNamedStyle extends NamedStyle {
+	/**
+	 * Returns the value of the '<em><b>Values</b></em>' attribute list.
+	 * The list contents are of type {@link java.lang.String}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Values</em>' attribute list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Values</em>' attribute list.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getStringListNamedStyle_Values()
+	 * @model ordered="false"
+	 * @generated
+	 */
+	EList<String> getValues();
+
+} // StringListNamedStyle
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StringNamedStyle.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StringNamedStyle.java
new file mode 100755
index 0000000..980669a
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StringNamedStyle.java
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>String Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <!-- begin-model-doc -->
+ * NamedStyle with a string as value
+ * <!-- end-model-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getStringNamedStyle()
+ * @model
+ * @generated
+ */
+public interface StringNamedStyle extends NamedStyle {
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(String)
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getStringNamedStyle_Value()
+	 * @model required="true" ordered="false"
+	 * @generated
+	 */
+	String getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @param value
+	 *            the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(String value);
+
+} // StringNamedStyle
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StyledElement.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StyledElement.java
new file mode 100755
index 0000000..fbae638
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StyledElement.java
@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Styled Element</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.StyledElement#getNamedStyles <em>Named Styles</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getStyledElement()
+ * @model interface="true" abstract="true"
+ * @generated
+ */
+public interface StyledElement extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Named Styles</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.papyrus.model2doc.core.styles.NamedStyle}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Named Styles</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the value of the '<em>Named Styles</em>' containment reference list.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#getStyledElement_NamedStyles()
+	 * @model containment="true" ordered="false"
+	 * @generated
+	 */
+	EList<NamedStyle> getNamedStyles();
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * <!-- begin-model-doc -->
+	 * This method return the NamedStyle corresponding to the given name
+	 * <!-- end-model-doc -->
+	 *
+	 * @model required="true" ordered="false" nameRequired="true" nameOrdered="false"
+	 * @generated
+	 */
+	NamedStyle getNamedStyle(String name);
+
+} // StyledElement
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StylesFactory.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StylesFactory.java
new file mode 100755
index 0000000..6e683dc
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StylesFactory.java
@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage
+ * @generated
+ */
+public interface StylesFactory extends EFactory {
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	StylesFactory eINSTANCE = org.eclipse.papyrus.model2doc.core.styles.impl.StylesFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>Int Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return a new object of class '<em>Int Named Style</em>'.
+	 * @generated
+	 */
+	IntNamedStyle createIntNamedStyle();
+
+	/**
+	 * Returns a new object of class '<em>String Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return a new object of class '<em>String Named Style</em>'.
+	 * @generated
+	 */
+	StringNamedStyle createStringNamedStyle();
+
+	/**
+	 * Returns a new object of class '<em>Boolean Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return a new object of class '<em>Boolean Named Style</em>'.
+	 * @generated
+	 */
+	BooleanNamedStyle createBooleanNamedStyle();
+
+	/**
+	 * Returns a new object of class '<em>Double Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return a new object of class '<em>Double Named Style</em>'.
+	 * @generated
+	 */
+	DoubleNamedStyle createDoubleNamedStyle();
+
+	/**
+	 * Returns a new object of class '<em>Int List Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return a new object of class '<em>Int List Named Style</em>'.
+	 * @generated
+	 */
+	IntListNamedStyle createIntListNamedStyle();
+
+	/**
+	 * Returns a new object of class '<em>String List Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return a new object of class '<em>String List Named Style</em>'.
+	 * @generated
+	 */
+	StringListNamedStyle createStringListNamedStyle();
+
+	/**
+	 * Returns a new object of class '<em>Boolean List Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return a new object of class '<em>Boolean List Named Style</em>'.
+	 * @generated
+	 */
+	BooleanListNamedStyle createBooleanListNamedStyle();
+
+	/**
+	 * Returns a new object of class '<em>Double List Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return a new object of class '<em>Double List Named Style</em>'.
+	 * @generated
+	 */
+	DoubleListNamedStyle createDoubleListNamedStyle();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	StylesPackage getStylesPackage();
+
+} // StylesFactory
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StylesPackage.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StylesPackage.java
new file mode 100755
index 0000000..a4cab37
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/StylesPackage.java
@@ -0,0 +1,1055 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EOperation;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ * <li>each class,</li>
+ * <li>each feature of each class,</li>
+ * <li>each operation of each class,</li>
+ * <li>each enum,</li>
+ * <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesFactory
+ * @model kind="package"
+ *        annotation="http://www.eclipse.org/uml2/2.0.0/UML originalName='Styles'"
+ * @generated
+ */
+public interface StylesPackage extends EPackage {
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	String eNAME = "styles"; //$NON-NLS-1$
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	String eNS_URI = "http://www.eclipse.org/papyrus/model2doc/core/1.0.0/Styles"; //$NON-NLS-1$
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	String eNS_PREFIX = "styles"; //$NON-NLS-1$
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	StylesPackage eINSTANCE = org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.NamedStyle <em>Named Style</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.NamedStyle
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getNamedStyle()
+	 * @generated
+	 */
+	int NAMED_STYLE = 0;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int NAMED_STYLE__NAME = 0;
+
+	/**
+	 * The number of structural features of the '<em>Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int NAMED_STYLE_FEATURE_COUNT = 1;
+
+	/**
+	 * The number of operations of the '<em>Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int NAMED_STYLE_OPERATION_COUNT = 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.IntNamedStyleImpl <em>Int Named Style</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.IntNamedStyleImpl
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getIntNamedStyle()
+	 * @generated
+	 */
+	int INT_NAMED_STYLE = 1;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int INT_NAMED_STYLE__NAME = NAMED_STYLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int INT_NAMED_STYLE__VALUE = NAMED_STYLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Int Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int INT_NAMED_STYLE_FEATURE_COUNT = NAMED_STYLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of operations of the '<em>Int Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int INT_NAMED_STYLE_OPERATION_COUNT = NAMED_STYLE_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.StringNamedStyleImpl <em>String Named Style</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StringNamedStyleImpl
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getStringNamedStyle()
+	 * @generated
+	 */
+	int STRING_NAMED_STYLE = 2;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_NAMED_STYLE__NAME = NAMED_STYLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_NAMED_STYLE__VALUE = NAMED_STYLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>String Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_NAMED_STYLE_FEATURE_COUNT = NAMED_STYLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of operations of the '<em>String Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_NAMED_STYLE_OPERATION_COUNT = NAMED_STYLE_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.BooleanNamedStyleImpl <em>Boolean Named Style</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.BooleanNamedStyleImpl
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getBooleanNamedStyle()
+	 * @generated
+	 */
+	int BOOLEAN_NAMED_STYLE = 3;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int BOOLEAN_NAMED_STYLE__NAME = NAMED_STYLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int BOOLEAN_NAMED_STYLE__VALUE = NAMED_STYLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Boolean Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int BOOLEAN_NAMED_STYLE_FEATURE_COUNT = NAMED_STYLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of operations of the '<em>Boolean Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int BOOLEAN_NAMED_STYLE_OPERATION_COUNT = NAMED_STYLE_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.DoubleNamedStyleImpl <em>Double Named Style</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.DoubleNamedStyleImpl
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getDoubleNamedStyle()
+	 * @generated
+	 */
+	int DOUBLE_NAMED_STYLE = 4;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_NAMED_STYLE__NAME = NAMED_STYLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_NAMED_STYLE__VALUE = NAMED_STYLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Double Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_NAMED_STYLE_FEATURE_COUNT = NAMED_STYLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of operations of the '<em>Double Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_NAMED_STYLE_OPERATION_COUNT = NAMED_STYLE_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.IntListNamedStyleImpl <em>Int List Named Style</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.IntListNamedStyleImpl
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getIntListNamedStyle()
+	 * @generated
+	 */
+	int INT_LIST_NAMED_STYLE = 5;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int INT_LIST_NAMED_STYLE__NAME = NAMED_STYLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Values</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int INT_LIST_NAMED_STYLE__VALUES = NAMED_STYLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Int List Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int INT_LIST_NAMED_STYLE_FEATURE_COUNT = NAMED_STYLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of operations of the '<em>Int List Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int INT_LIST_NAMED_STYLE_OPERATION_COUNT = NAMED_STYLE_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.StringListNamedStyleImpl <em>String List Named Style</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StringListNamedStyleImpl
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getStringListNamedStyle()
+	 * @generated
+	 */
+	int STRING_LIST_NAMED_STYLE = 6;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_LIST_NAMED_STYLE__NAME = NAMED_STYLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Values</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_LIST_NAMED_STYLE__VALUES = NAMED_STYLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>String List Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_LIST_NAMED_STYLE_FEATURE_COUNT = NAMED_STYLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of operations of the '<em>String List Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_LIST_NAMED_STYLE_OPERATION_COUNT = NAMED_STYLE_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.BooleanListNamedStyleImpl <em>Boolean List Named Style</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.BooleanListNamedStyleImpl
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getBooleanListNamedStyle()
+	 * @generated
+	 */
+	int BOOLEAN_LIST_NAMED_STYLE = 7;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int BOOLEAN_LIST_NAMED_STYLE__NAME = NAMED_STYLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Values</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int BOOLEAN_LIST_NAMED_STYLE__VALUES = NAMED_STYLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Boolean List Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int BOOLEAN_LIST_NAMED_STYLE_FEATURE_COUNT = NAMED_STYLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of operations of the '<em>Boolean List Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int BOOLEAN_LIST_NAMED_STYLE_OPERATION_COUNT = NAMED_STYLE_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.DoubleListNamedStyleImpl <em>Double List Named Style</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.DoubleListNamedStyleImpl
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getDoubleListNamedStyle()
+	 * @generated
+	 */
+	int DOUBLE_LIST_NAMED_STYLE = 8;
+
+	/**
+	 * The feature id for the '<em><b>Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_LIST_NAMED_STYLE__NAME = NAMED_STYLE__NAME;
+
+	/**
+	 * The feature id for the '<em><b>Values</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_LIST_NAMED_STYLE__VALUES = NAMED_STYLE_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of structural features of the '<em>Double List Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_LIST_NAMED_STYLE_FEATURE_COUNT = NAMED_STYLE_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of operations of the '<em>Double List Named Style</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_LIST_NAMED_STYLE_OPERATION_COUNT = NAMED_STYLE_OPERATION_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.core.styles.StyledElement <em>Styled Element</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StyledElement
+	 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getStyledElement()
+	 * @generated
+	 */
+	int STYLED_ELEMENT = 9;
+
+	/**
+	 * The feature id for the '<em><b>Named Styles</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STYLED_ELEMENT__NAMED_STYLES = 0;
+
+	/**
+	 * The number of structural features of the '<em>Styled Element</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STYLED_ELEMENT_FEATURE_COUNT = 1;
+
+	/**
+	 * The operation id for the '<em>Get Named Style</em>' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STYLED_ELEMENT___GET_NAMED_STYLE__STRING = 0;
+
+	/**
+	 * The number of operations of the '<em>Styled Element</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int STYLED_ELEMENT_OPERATION_COUNT = 1;
+
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.NamedStyle <em>Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>Named Style</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.NamedStyle
+	 * @generated
+	 */
+	EClass getNamedStyle();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.model2doc.core.styles.NamedStyle#getName <em>Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the attribute '<em>Name</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.NamedStyle#getName()
+	 * @see #getNamedStyle()
+	 * @generated
+	 */
+	EAttribute getNamedStyle_Name();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle <em>Int Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>Int Named Style</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle
+	 * @generated
+	 */
+	EClass getIntNamedStyle();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle#getValue()
+	 * @see #getIntNamedStyle()
+	 * @generated
+	 */
+	EAttribute getIntNamedStyle_Value();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle <em>String Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>String Named Style</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle
+	 * @generated
+	 */
+	EClass getStringNamedStyle();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle#getValue()
+	 * @see #getStringNamedStyle()
+	 * @generated
+	 */
+	EAttribute getStringNamedStyle_Value();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle <em>Boolean Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>Boolean Named Style</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle
+	 * @generated
+	 */
+	EClass getBooleanNamedStyle();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle#isValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle#isValue()
+	 * @see #getBooleanNamedStyle()
+	 * @generated
+	 */
+	EAttribute getBooleanNamedStyle_Value();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle <em>Double Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>Double Named Style</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle
+	 * @generated
+	 */
+	EClass getDoubleNamedStyle();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle#getValue()
+	 * @see #getDoubleNamedStyle()
+	 * @generated
+	 */
+	EAttribute getDoubleNamedStyle_Value();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle <em>Int List Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>Int List Named Style</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle
+	 * @generated
+	 */
+	EClass getIntListNamedStyle();
+
+	/**
+	 * Returns the meta object for the attribute list '{@link org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle#getValues <em>Values</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the attribute list '<em>Values</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle#getValues()
+	 * @see #getIntListNamedStyle()
+	 * @generated
+	 */
+	EAttribute getIntListNamedStyle_Values();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle <em>String List Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>String List Named Style</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle
+	 * @generated
+	 */
+	EClass getStringListNamedStyle();
+
+	/**
+	 * Returns the meta object for the attribute list '{@link org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle#getValues <em>Values</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the attribute list '<em>Values</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle#getValues()
+	 * @see #getStringListNamedStyle()
+	 * @generated
+	 */
+	EAttribute getStringListNamedStyle_Values();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle <em>Boolean List Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>Boolean List Named Style</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle
+	 * @generated
+	 */
+	EClass getBooleanListNamedStyle();
+
+	/**
+	 * Returns the meta object for the attribute list '{@link org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle#getValues <em>Values</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the attribute list '<em>Values</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle#getValues()
+	 * @see #getBooleanListNamedStyle()
+	 * @generated
+	 */
+	EAttribute getBooleanListNamedStyle_Values();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle <em>Double List Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>Double List Named Style</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle
+	 * @generated
+	 */
+	EClass getDoubleListNamedStyle();
+
+	/**
+	 * Returns the meta object for the attribute list '{@link org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle#getValues <em>Values</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the attribute list '<em>Values</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle#getValues()
+	 * @see #getDoubleListNamedStyle()
+	 * @generated
+	 */
+	EAttribute getDoubleListNamedStyle_Values();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.model2doc.core.styles.StyledElement <em>Styled Element</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for class '<em>Styled Element</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StyledElement
+	 * @generated
+	 */
+	EClass getStyledElement();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.papyrus.model2doc.core.styles.StyledElement#getNamedStyles <em>Named Styles</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the containment reference list '<em>Named Styles</em>'.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StyledElement#getNamedStyles()
+	 * @see #getStyledElement()
+	 * @generated
+	 */
+	EReference getStyledElement_NamedStyles();
+
+	/**
+	 * Returns the meta object for the '{@link org.eclipse.papyrus.model2doc.core.styles.StyledElement#getNamedStyle(java.lang.String) <em>Get Named Style</em>}' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the meta object for the '<em>Get Named Style</em>' operation.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StyledElement#getNamedStyle(java.lang.String)
+	 * @generated
+	 */
+	EOperation getStyledElement__GetNamedStyle__String();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	StylesFactory getStylesFactory();
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * Defines literals for the meta objects that represent
+	 * <ul>
+	 * <li>each class,</li>
+	 * <li>each feature of each class,</li>
+	 * <li>each operation of each class,</li>
+	 * <li>each enum,</li>
+	 * <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.NamedStyle <em>Named Style</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.NamedStyle
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getNamedStyle()
+		 * @generated
+		 */
+		EClass NAMED_STYLE = eINSTANCE.getNamedStyle();
+
+		/**
+		 * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EAttribute NAMED_STYLE__NAME = eINSTANCE.getNamedStyle_Name();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.IntNamedStyleImpl <em>Int Named Style</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.IntNamedStyleImpl
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getIntNamedStyle()
+		 * @generated
+		 */
+		EClass INT_NAMED_STYLE = eINSTANCE.getIntNamedStyle();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EAttribute INT_NAMED_STYLE__VALUE = eINSTANCE.getIntNamedStyle_Value();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.StringNamedStyleImpl <em>String Named Style</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StringNamedStyleImpl
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getStringNamedStyle()
+		 * @generated
+		 */
+		EClass STRING_NAMED_STYLE = eINSTANCE.getStringNamedStyle();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EAttribute STRING_NAMED_STYLE__VALUE = eINSTANCE.getStringNamedStyle_Value();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.BooleanNamedStyleImpl <em>Boolean Named Style</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.BooleanNamedStyleImpl
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getBooleanNamedStyle()
+		 * @generated
+		 */
+		EClass BOOLEAN_NAMED_STYLE = eINSTANCE.getBooleanNamedStyle();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EAttribute BOOLEAN_NAMED_STYLE__VALUE = eINSTANCE.getBooleanNamedStyle_Value();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.DoubleNamedStyleImpl <em>Double Named Style</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.DoubleNamedStyleImpl
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getDoubleNamedStyle()
+		 * @generated
+		 */
+		EClass DOUBLE_NAMED_STYLE = eINSTANCE.getDoubleNamedStyle();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EAttribute DOUBLE_NAMED_STYLE__VALUE = eINSTANCE.getDoubleNamedStyle_Value();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.IntListNamedStyleImpl <em>Int List Named Style</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.IntListNamedStyleImpl
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getIntListNamedStyle()
+		 * @generated
+		 */
+		EClass INT_LIST_NAMED_STYLE = eINSTANCE.getIntListNamedStyle();
+
+		/**
+		 * The meta object literal for the '<em><b>Values</b></em>' attribute list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EAttribute INT_LIST_NAMED_STYLE__VALUES = eINSTANCE.getIntListNamedStyle_Values();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.StringListNamedStyleImpl <em>String List Named Style</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StringListNamedStyleImpl
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getStringListNamedStyle()
+		 * @generated
+		 */
+		EClass STRING_LIST_NAMED_STYLE = eINSTANCE.getStringListNamedStyle();
+
+		/**
+		 * The meta object literal for the '<em><b>Values</b></em>' attribute list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EAttribute STRING_LIST_NAMED_STYLE__VALUES = eINSTANCE.getStringListNamedStyle_Values();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.BooleanListNamedStyleImpl <em>Boolean List Named Style</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.BooleanListNamedStyleImpl
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getBooleanListNamedStyle()
+		 * @generated
+		 */
+		EClass BOOLEAN_LIST_NAMED_STYLE = eINSTANCE.getBooleanListNamedStyle();
+
+		/**
+		 * The meta object literal for the '<em><b>Values</b></em>' attribute list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EAttribute BOOLEAN_LIST_NAMED_STYLE__VALUES = eINSTANCE.getBooleanListNamedStyle_Values();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.impl.DoubleListNamedStyleImpl <em>Double List Named Style</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.DoubleListNamedStyleImpl
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getDoubleListNamedStyle()
+		 * @generated
+		 */
+		EClass DOUBLE_LIST_NAMED_STYLE = eINSTANCE.getDoubleListNamedStyle();
+
+		/**
+		 * The meta object literal for the '<em><b>Values</b></em>' attribute list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EAttribute DOUBLE_LIST_NAMED_STYLE__VALUES = eINSTANCE.getDoubleListNamedStyle_Values();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.model2doc.core.styles.StyledElement <em>Styled Element</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @see org.eclipse.papyrus.model2doc.core.styles.StyledElement
+		 * @see org.eclipse.papyrus.model2doc.core.styles.impl.StylesPackageImpl#getStyledElement()
+		 * @generated
+		 */
+		EClass STYLED_ELEMENT = eINSTANCE.getStyledElement();
+
+		/**
+		 * The meta object literal for the '<em><b>Named Styles</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EReference STYLED_ELEMENT__NAMED_STYLES = eINSTANCE.getStyledElement_NamedStyles();
+
+		/**
+		 * The meta object literal for the '<em><b>Get Named Style</b></em>' operation.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 *
+		 * @generated
+		 */
+		EOperation STYLED_ELEMENT___GET_NAMED_STYLE__STRING = eINSTANCE.getStyledElement__GetNamedStyle__String();
+
+	}
+
+} // StylesPackage
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/BooleanListNamedStyleImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/BooleanListNamedStyleImpl.java
new file mode 100755
index 0000000..b76bc67
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/BooleanListNamedStyleImpl.java
@@ -0,0 +1,236 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+
+import org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Boolean List Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.BooleanListNamedStyleImpl#getName <em>Name</em>}</li>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.BooleanListNamedStyleImpl#getValues <em>Values</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class BooleanListNamedStyleImpl extends MinimalEObjectImpl.Container implements BooleanListNamedStyle {
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getValues() <em>Values</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValues()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Boolean> values;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected BooleanListNamedStyleImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return StylesPackage.Literals.BOOLEAN_LIST_NAMED_STYLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.BOOLEAN_LIST_NAMED_STYLE__NAME, oldName, name));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EList<Boolean> getValues() {
+		if (values == null) {
+			values = new EDataTypeUniqueEList<>(Boolean.class, this, StylesPackage.BOOLEAN_LIST_NAMED_STYLE__VALUES);
+		}
+		return values;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__NAME:
+			return getName();
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__VALUES:
+			return getValues();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__NAME:
+			setName((String) newValue);
+			return;
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__VALUES:
+			getValues().clear();
+			getValues().addAll((Collection<? extends Boolean>) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__NAME:
+			setName(NAME_EDEFAULT);
+			return;
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__VALUES:
+			getValues().clear();
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__NAME:
+			return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE__VALUES:
+			return values != null && !values.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: "); //$NON-NLS-1$
+		result.append(name);
+		result.append(", values: "); //$NON-NLS-1$
+		result.append(values);
+		result.append(')');
+		return result.toString();
+	}
+
+} // BooleanListNamedStyleImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/BooleanNamedStyleImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/BooleanNamedStyleImpl.java
new file mode 100755
index 0000000..6ddeb7d
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/BooleanNamedStyleImpl.java
@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Boolean Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.BooleanNamedStyleImpl#getName <em>Name</em>}</li>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.BooleanNamedStyleImpl#isValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class BooleanNamedStyleImpl extends MinimalEObjectImpl.Container implements BooleanNamedStyle {
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #isValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean VALUE_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #isValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean value = VALUE_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected BooleanNamedStyleImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return StylesPackage.Literals.BOOLEAN_NAMED_STYLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.BOOLEAN_NAMED_STYLE__NAME, oldName, name));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean isValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setValue(boolean newValue) {
+		boolean oldValue = value;
+		value = newValue;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.BOOLEAN_NAMED_STYLE__VALUE, oldValue, value));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case StylesPackage.BOOLEAN_NAMED_STYLE__NAME:
+			return getName();
+		case StylesPackage.BOOLEAN_NAMED_STYLE__VALUE:
+			return isValue();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case StylesPackage.BOOLEAN_NAMED_STYLE__NAME:
+			setName((String) newValue);
+			return;
+		case StylesPackage.BOOLEAN_NAMED_STYLE__VALUE:
+			setValue((Boolean) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case StylesPackage.BOOLEAN_NAMED_STYLE__NAME:
+			setName(NAME_EDEFAULT);
+			return;
+		case StylesPackage.BOOLEAN_NAMED_STYLE__VALUE:
+			setValue(VALUE_EDEFAULT);
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case StylesPackage.BOOLEAN_NAMED_STYLE__NAME:
+			return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+		case StylesPackage.BOOLEAN_NAMED_STYLE__VALUE:
+			return value != VALUE_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: "); //$NON-NLS-1$
+		result.append(name);
+		result.append(", value: "); //$NON-NLS-1$
+		result.append(value);
+		result.append(')');
+		return result.toString();
+	}
+
+} // BooleanNamedStyleImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/DoubleListNamedStyleImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/DoubleListNamedStyleImpl.java
new file mode 100755
index 0000000..8329df1
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/DoubleListNamedStyleImpl.java
@@ -0,0 +1,236 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+
+import org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Double List Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.DoubleListNamedStyleImpl#getName <em>Name</em>}</li>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.DoubleListNamedStyleImpl#getValues <em>Values</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class DoubleListNamedStyleImpl extends MinimalEObjectImpl.Container implements DoubleListNamedStyle {
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getValues() <em>Values</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValues()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Double> values;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected DoubleListNamedStyleImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return StylesPackage.Literals.DOUBLE_LIST_NAMED_STYLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.DOUBLE_LIST_NAMED_STYLE__NAME, oldName, name));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EList<Double> getValues() {
+		if (values == null) {
+			values = new EDataTypeUniqueEList<>(Double.class, this, StylesPackage.DOUBLE_LIST_NAMED_STYLE__VALUES);
+		}
+		return values;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__NAME:
+			return getName();
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__VALUES:
+			return getValues();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__NAME:
+			setName((String) newValue);
+			return;
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__VALUES:
+			getValues().clear();
+			getValues().addAll((Collection<? extends Double>) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__NAME:
+			setName(NAME_EDEFAULT);
+			return;
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__VALUES:
+			getValues().clear();
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__NAME:
+			return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE__VALUES:
+			return values != null && !values.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: "); //$NON-NLS-1$
+		result.append(name);
+		result.append(", values: "); //$NON-NLS-1$
+		result.append(values);
+		result.append(')');
+		return result.toString();
+	}
+
+} // DoubleListNamedStyleImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/DoubleNamedStyleImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/DoubleNamedStyleImpl.java
new file mode 100755
index 0000000..22e295d
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/DoubleNamedStyleImpl.java
@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Double Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.DoubleNamedStyleImpl#getName <em>Name</em>}</li>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.DoubleNamedStyleImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class DoubleNamedStyleImpl extends MinimalEObjectImpl.Container implements DoubleNamedStyle {
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double VALUE_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected double value = VALUE_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected DoubleNamedStyleImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return StylesPackage.Literals.DOUBLE_NAMED_STYLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.DOUBLE_NAMED_STYLE__NAME, oldName, name));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public double getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setValue(double newValue) {
+		double oldValue = value;
+		value = newValue;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.DOUBLE_NAMED_STYLE__VALUE, oldValue, value));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case StylesPackage.DOUBLE_NAMED_STYLE__NAME:
+			return getName();
+		case StylesPackage.DOUBLE_NAMED_STYLE__VALUE:
+			return getValue();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case StylesPackage.DOUBLE_NAMED_STYLE__NAME:
+			setName((String) newValue);
+			return;
+		case StylesPackage.DOUBLE_NAMED_STYLE__VALUE:
+			setValue((Double) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case StylesPackage.DOUBLE_NAMED_STYLE__NAME:
+			setName(NAME_EDEFAULT);
+			return;
+		case StylesPackage.DOUBLE_NAMED_STYLE__VALUE:
+			setValue(VALUE_EDEFAULT);
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case StylesPackage.DOUBLE_NAMED_STYLE__NAME:
+			return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+		case StylesPackage.DOUBLE_NAMED_STYLE__VALUE:
+			return value != VALUE_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: "); //$NON-NLS-1$
+		result.append(name);
+		result.append(", value: "); //$NON-NLS-1$
+		result.append(value);
+		result.append(')');
+		return result.toString();
+	}
+
+} // DoubleNamedStyleImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/IntListNamedStyleImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/IntListNamedStyleImpl.java
new file mode 100755
index 0000000..58b8670
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/IntListNamedStyleImpl.java
@@ -0,0 +1,236 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+
+import org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Int List Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.IntListNamedStyleImpl#getName <em>Name</em>}</li>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.IntListNamedStyleImpl#getValues <em>Values</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class IntListNamedStyleImpl extends MinimalEObjectImpl.Container implements IntListNamedStyle {
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getValues() <em>Values</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValues()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Integer> values;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected IntListNamedStyleImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return StylesPackage.Literals.INT_LIST_NAMED_STYLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.INT_LIST_NAMED_STYLE__NAME, oldName, name));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EList<Integer> getValues() {
+		if (values == null) {
+			values = new EDataTypeUniqueEList<>(Integer.class, this, StylesPackage.INT_LIST_NAMED_STYLE__VALUES);
+		}
+		return values;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case StylesPackage.INT_LIST_NAMED_STYLE__NAME:
+			return getName();
+		case StylesPackage.INT_LIST_NAMED_STYLE__VALUES:
+			return getValues();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case StylesPackage.INT_LIST_NAMED_STYLE__NAME:
+			setName((String) newValue);
+			return;
+		case StylesPackage.INT_LIST_NAMED_STYLE__VALUES:
+			getValues().clear();
+			getValues().addAll((Collection<? extends Integer>) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case StylesPackage.INT_LIST_NAMED_STYLE__NAME:
+			setName(NAME_EDEFAULT);
+			return;
+		case StylesPackage.INT_LIST_NAMED_STYLE__VALUES:
+			getValues().clear();
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case StylesPackage.INT_LIST_NAMED_STYLE__NAME:
+			return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+		case StylesPackage.INT_LIST_NAMED_STYLE__VALUES:
+			return values != null && !values.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: "); //$NON-NLS-1$
+		result.append(name);
+		result.append(", values: "); //$NON-NLS-1$
+		result.append(values);
+		result.append(')');
+		return result.toString();
+	}
+
+} // IntListNamedStyleImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/IntNamedStyleImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/IntNamedStyleImpl.java
new file mode 100755
index 0000000..d6d150d
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/IntNamedStyleImpl.java
@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Int Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.IntNamedStyleImpl#getName <em>Name</em>}</li>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.IntNamedStyleImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class IntNamedStyleImpl extends MinimalEObjectImpl.Container implements IntNamedStyle {
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int VALUE_EDEFAULT = 0;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected int value = VALUE_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected IntNamedStyleImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return StylesPackage.Literals.INT_NAMED_STYLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.INT_NAMED_STYLE__NAME, oldName, name));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public int getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setValue(int newValue) {
+		int oldValue = value;
+		value = newValue;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.INT_NAMED_STYLE__VALUE, oldValue, value));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case StylesPackage.INT_NAMED_STYLE__NAME:
+			return getName();
+		case StylesPackage.INT_NAMED_STYLE__VALUE:
+			return getValue();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case StylesPackage.INT_NAMED_STYLE__NAME:
+			setName((String) newValue);
+			return;
+		case StylesPackage.INT_NAMED_STYLE__VALUE:
+			setValue((Integer) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case StylesPackage.INT_NAMED_STYLE__NAME:
+			setName(NAME_EDEFAULT);
+			return;
+		case StylesPackage.INT_NAMED_STYLE__VALUE:
+			setValue(VALUE_EDEFAULT);
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case StylesPackage.INT_NAMED_STYLE__NAME:
+			return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+		case StylesPackage.INT_NAMED_STYLE__VALUE:
+			return value != VALUE_EDEFAULT;
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: "); //$NON-NLS-1$
+		result.append(name);
+		result.append(", value: "); //$NON-NLS-1$
+		result.append(value);
+		result.append(')');
+		return result.toString();
+	}
+
+} // IntNamedStyleImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StringListNamedStyleImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StringListNamedStyleImpl.java
new file mode 100755
index 0000000..e08359e
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StringListNamedStyleImpl.java
@@ -0,0 +1,236 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+
+import org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>String List Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.StringListNamedStyleImpl#getName <em>Name</em>}</li>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.StringListNamedStyleImpl#getValues <em>Values</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class StringListNamedStyleImpl extends MinimalEObjectImpl.Container implements StringListNamedStyle {
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The cached value of the '{@link #getValues() <em>Values</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValues()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> values;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected StringListNamedStyleImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return StylesPackage.Literals.STRING_LIST_NAMED_STYLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.STRING_LIST_NAMED_STYLE__NAME, oldName, name));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EList<String> getValues() {
+		if (values == null) {
+			values = new EDataTypeUniqueEList<>(String.class, this, StylesPackage.STRING_LIST_NAMED_STYLE__VALUES);
+		}
+		return values;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case StylesPackage.STRING_LIST_NAMED_STYLE__NAME:
+			return getName();
+		case StylesPackage.STRING_LIST_NAMED_STYLE__VALUES:
+			return getValues();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case StylesPackage.STRING_LIST_NAMED_STYLE__NAME:
+			setName((String) newValue);
+			return;
+		case StylesPackage.STRING_LIST_NAMED_STYLE__VALUES:
+			getValues().clear();
+			getValues().addAll((Collection<? extends String>) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case StylesPackage.STRING_LIST_NAMED_STYLE__NAME:
+			setName(NAME_EDEFAULT);
+			return;
+		case StylesPackage.STRING_LIST_NAMED_STYLE__VALUES:
+			getValues().clear();
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case StylesPackage.STRING_LIST_NAMED_STYLE__NAME:
+			return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+		case StylesPackage.STRING_LIST_NAMED_STYLE__VALUES:
+			return values != null && !values.isEmpty();
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: "); //$NON-NLS-1$
+		result.append(name);
+		result.append(", values: "); //$NON-NLS-1$
+		result.append(values);
+		result.append(')');
+		return result.toString();
+	}
+
+} // StringListNamedStyleImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StringNamedStyleImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StringNamedStyleImpl.java
new file mode 100755
index 0000000..6b8bbe1
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StringNamedStyleImpl.java
@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>String Named Style</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.StringNamedStyleImpl#getName <em>Name</em>}</li>
+ * <li>{@link org.eclipse.papyrus.model2doc.core.styles.impl.StringNamedStyleImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class StringNamedStyleImpl extends MinimalEObjectImpl.Container implements StringNamedStyle {
+	/**
+	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String name = NAME_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String VALUE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected String value = VALUE_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected StringNamedStyleImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return StylesPackage.Literals.STRING_NAMED_STYLE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setName(String newName) {
+		String oldName = name;
+		name = newName;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.STRING_NAMED_STYLE__NAME, oldName, name));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void setValue(String newValue) {
+		String oldValue = value;
+		value = newValue;
+		if (eNotificationRequired()) {
+			eNotify(new ENotificationImpl(this, Notification.SET, StylesPackage.STRING_NAMED_STYLE__VALUE, oldValue, value));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case StylesPackage.STRING_NAMED_STYLE__NAME:
+			return getName();
+		case StylesPackage.STRING_NAMED_STYLE__VALUE:
+			return getValue();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case StylesPackage.STRING_NAMED_STYLE__NAME:
+			setName((String) newValue);
+			return;
+		case StylesPackage.STRING_NAMED_STYLE__VALUE:
+			setValue((String) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case StylesPackage.STRING_NAMED_STYLE__NAME:
+			setName(NAME_EDEFAULT);
+			return;
+		case StylesPackage.STRING_NAMED_STYLE__VALUE:
+			setValue(VALUE_EDEFAULT);
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case StylesPackage.STRING_NAMED_STYLE__NAME:
+			return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+		case StylesPackage.STRING_NAMED_STYLE__VALUE:
+			return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) {
+			return super.toString();
+		}
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (name: "); //$NON-NLS-1$
+		result.append(name);
+		result.append(", value: "); //$NON-NLS-1$
+		result.append(value);
+		result.append(')');
+		return result.toString();
+	}
+
+} // StringNamedStyleImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StylesFactoryImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StylesFactoryImpl.java
new file mode 100755
index 0000000..679a8e7
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StylesFactoryImpl.java
@@ -0,0 +1,213 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+import org.eclipse.papyrus.model2doc.core.styles.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class StylesFactoryImpl extends EFactoryImpl implements StylesFactory {
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public static StylesFactory init() {
+		try {
+			StylesFactory theStylesFactory = (StylesFactory) EPackage.Registry.INSTANCE.getEFactory(StylesPackage.eNS_URI);
+			if (theStylesFactory != null) {
+				return theStylesFactory;
+			}
+		} catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new StylesFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public StylesFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+		case StylesPackage.INT_NAMED_STYLE:
+			return createIntNamedStyle();
+		case StylesPackage.STRING_NAMED_STYLE:
+			return createStringNamedStyle();
+		case StylesPackage.BOOLEAN_NAMED_STYLE:
+			return createBooleanNamedStyle();
+		case StylesPackage.DOUBLE_NAMED_STYLE:
+			return createDoubleNamedStyle();
+		case StylesPackage.INT_LIST_NAMED_STYLE:
+			return createIntListNamedStyle();
+		case StylesPackage.STRING_LIST_NAMED_STYLE:
+			return createStringListNamedStyle();
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE:
+			return createBooleanListNamedStyle();
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE:
+			return createDoubleListNamedStyle();
+		default:
+			throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public IntNamedStyle createIntNamedStyle() {
+		IntNamedStyleImpl intNamedStyle = new IntNamedStyleImpl();
+		return intNamedStyle;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public StringNamedStyle createStringNamedStyle() {
+		StringNamedStyleImpl stringNamedStyle = new StringNamedStyleImpl();
+		return stringNamedStyle;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public BooleanNamedStyle createBooleanNamedStyle() {
+		BooleanNamedStyleImpl booleanNamedStyle = new BooleanNamedStyleImpl();
+		return booleanNamedStyle;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public DoubleNamedStyle createDoubleNamedStyle() {
+		DoubleNamedStyleImpl doubleNamedStyle = new DoubleNamedStyleImpl();
+		return doubleNamedStyle;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public IntListNamedStyle createIntListNamedStyle() {
+		IntListNamedStyleImpl intListNamedStyle = new IntListNamedStyleImpl();
+		return intListNamedStyle;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public StringListNamedStyle createStringListNamedStyle() {
+		StringListNamedStyleImpl stringListNamedStyle = new StringListNamedStyleImpl();
+		return stringListNamedStyle;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public BooleanListNamedStyle createBooleanListNamedStyle() {
+		BooleanListNamedStyleImpl booleanListNamedStyle = new BooleanListNamedStyleImpl();
+		return booleanListNamedStyle;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public DoubleListNamedStyle createDoubleListNamedStyle() {
+		DoubleListNamedStyleImpl doubleListNamedStyle = new DoubleListNamedStyleImpl();
+		return doubleListNamedStyle;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public StylesPackage getStylesPackage() {
+		return (StylesPackage) getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static StylesPackage getPackage() {
+		return StylesPackage.eINSTANCE;
+	}
+
+} // StylesFactoryImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StylesPackageImpl.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StylesPackageImpl.java
new file mode 100755
index 0000000..35b0e1e
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/impl/StylesPackageImpl.java
@@ -0,0 +1,590 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EOperation;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+import org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.NamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle;
+import org.eclipse.papyrus.model2doc.core.styles.StyledElement;
+import org.eclipse.papyrus.model2doc.core.styles.StylesFactory;
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class StylesPackageImpl extends EPackageImpl implements StylesPackage {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass namedStyleEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass intNamedStyleEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass stringNamedStyleEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass booleanNamedStyleEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass doubleNamedStyleEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass intListNamedStyleEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass stringListNamedStyleEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass booleanListNamedStyleEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass doubleListNamedStyleEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private EClass styledElementEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>
+	 * Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private StylesPackageImpl() {
+		super(eNS_URI, StylesFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+	 *
+	 * <p>
+	 * This method is used to initialize {@link StylesPackage#eINSTANCE} when that field is accessed.
+	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static StylesPackage init() {
+		if (isInited) {
+			return (StylesPackage) EPackage.Registry.INSTANCE.getEPackage(StylesPackage.eNS_URI);
+		}
+
+		// Obtain or create and register package
+		Object registeredStylesPackage = EPackage.Registry.INSTANCE.get(eNS_URI);
+		StylesPackageImpl theStylesPackage = registeredStylesPackage instanceof StylesPackageImpl ? (StylesPackageImpl) registeredStylesPackage : new StylesPackageImpl();
+
+		isInited = true;
+
+		// Create package meta-data objects
+		theStylesPackage.createPackageContents();
+
+		// Initialize created meta-data
+		theStylesPackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theStylesPackage.freeze();
+
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(StylesPackage.eNS_URI, theStylesPackage);
+		return theStylesPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getNamedStyle() {
+		return namedStyleEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EAttribute getNamedStyle_Name() {
+		return (EAttribute) namedStyleEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getIntNamedStyle() {
+		return intNamedStyleEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EAttribute getIntNamedStyle_Value() {
+		return (EAttribute) intNamedStyleEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getStringNamedStyle() {
+		return stringNamedStyleEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EAttribute getStringNamedStyle_Value() {
+		return (EAttribute) stringNamedStyleEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getBooleanNamedStyle() {
+		return booleanNamedStyleEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EAttribute getBooleanNamedStyle_Value() {
+		return (EAttribute) booleanNamedStyleEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getDoubleNamedStyle() {
+		return doubleNamedStyleEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EAttribute getDoubleNamedStyle_Value() {
+		return (EAttribute) doubleNamedStyleEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getIntListNamedStyle() {
+		return intListNamedStyleEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EAttribute getIntListNamedStyle_Values() {
+		return (EAttribute) intListNamedStyleEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getStringListNamedStyle() {
+		return stringListNamedStyleEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EAttribute getStringListNamedStyle_Values() {
+		return (EAttribute) stringListNamedStyleEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getBooleanListNamedStyle() {
+		return booleanListNamedStyleEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EAttribute getBooleanListNamedStyle_Values() {
+		return (EAttribute) booleanListNamedStyleEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getDoubleListNamedStyle() {
+		return doubleListNamedStyleEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EAttribute getDoubleListNamedStyle_Values() {
+		return (EAttribute) doubleListNamedStyleEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EClass getStyledElement() {
+		return styledElementEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EReference getStyledElement_NamedStyles() {
+		return (EReference) styledElementEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public EOperation getStyledElement__GetNamedStyle__String() {
+		return styledElementEClass.getEOperations().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	@Override
+	public StylesFactory getStylesFactory() {
+		return (StylesFactory) getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package. This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) {
+			return;
+		}
+		isCreated = true;
+
+		// Create classes and their features
+		namedStyleEClass = createEClass(NAMED_STYLE);
+		createEAttribute(namedStyleEClass, NAMED_STYLE__NAME);
+
+		intNamedStyleEClass = createEClass(INT_NAMED_STYLE);
+		createEAttribute(intNamedStyleEClass, INT_NAMED_STYLE__VALUE);
+
+		stringNamedStyleEClass = createEClass(STRING_NAMED_STYLE);
+		createEAttribute(stringNamedStyleEClass, STRING_NAMED_STYLE__VALUE);
+
+		booleanNamedStyleEClass = createEClass(BOOLEAN_NAMED_STYLE);
+		createEAttribute(booleanNamedStyleEClass, BOOLEAN_NAMED_STYLE__VALUE);
+
+		doubleNamedStyleEClass = createEClass(DOUBLE_NAMED_STYLE);
+		createEAttribute(doubleNamedStyleEClass, DOUBLE_NAMED_STYLE__VALUE);
+
+		intListNamedStyleEClass = createEClass(INT_LIST_NAMED_STYLE);
+		createEAttribute(intListNamedStyleEClass, INT_LIST_NAMED_STYLE__VALUES);
+
+		stringListNamedStyleEClass = createEClass(STRING_LIST_NAMED_STYLE);
+		createEAttribute(stringListNamedStyleEClass, STRING_LIST_NAMED_STYLE__VALUES);
+
+		booleanListNamedStyleEClass = createEClass(BOOLEAN_LIST_NAMED_STYLE);
+		createEAttribute(booleanListNamedStyleEClass, BOOLEAN_LIST_NAMED_STYLE__VALUES);
+
+		doubleListNamedStyleEClass = createEClass(DOUBLE_LIST_NAMED_STYLE);
+		createEAttribute(doubleListNamedStyleEClass, DOUBLE_LIST_NAMED_STYLE__VALUES);
+
+		styledElementEClass = createEClass(STYLED_ELEMENT);
+		createEReference(styledElementEClass, STYLED_ELEMENT__NAMED_STYLES);
+		createEOperation(styledElementEClass, STYLED_ELEMENT___GET_NAMED_STYLE__STRING);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model. This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) {
+			return;
+		}
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		intNamedStyleEClass.getESuperTypes().add(this.getNamedStyle());
+		stringNamedStyleEClass.getESuperTypes().add(this.getNamedStyle());
+		booleanNamedStyleEClass.getESuperTypes().add(this.getNamedStyle());
+		doubleNamedStyleEClass.getESuperTypes().add(this.getNamedStyle());
+		intListNamedStyleEClass.getESuperTypes().add(this.getNamedStyle());
+		stringListNamedStyleEClass.getESuperTypes().add(this.getNamedStyle());
+		booleanListNamedStyleEClass.getESuperTypes().add(this.getNamedStyle());
+		doubleListNamedStyleEClass.getESuperTypes().add(this.getNamedStyle());
+
+		// Initialize classes, features, and operations; add parameters
+		initEClass(namedStyleEClass, NamedStyle.class, "NamedStyle", IS_ABSTRACT, IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getNamedStyle_Name(), ecorePackage.getEString(), "name", null, 1, 1, NamedStyle.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(intNamedStyleEClass, IntNamedStyle.class, "IntNamedStyle", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getIntNamedStyle_Value(), ecorePackage.getEInt(), "value", null, 1, 1, IntNamedStyle.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(stringNamedStyleEClass, StringNamedStyle.class, "StringNamedStyle", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getStringNamedStyle_Value(), ecorePackage.getEString(), "value", null, 1, 1, StringNamedStyle.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(booleanNamedStyleEClass, BooleanNamedStyle.class, "BooleanNamedStyle", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getBooleanNamedStyle_Value(), ecorePackage.getEBoolean(), "value", null, 1, 1, BooleanNamedStyle.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(doubleNamedStyleEClass, DoubleNamedStyle.class, "DoubleNamedStyle", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getDoubleNamedStyle_Value(), ecorePackage.getEDouble(), "value", null, 1, 1, DoubleNamedStyle.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(intListNamedStyleEClass, IntListNamedStyle.class, "IntListNamedStyle", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getIntListNamedStyle_Values(), ecorePackage.getEInt(), "values", null, 0, -1, IntListNamedStyle.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(stringListNamedStyleEClass, StringListNamedStyle.class, "StringListNamedStyle", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getStringListNamedStyle_Values(), ecorePackage.getEString(), "values", null, 0, -1, StringListNamedStyle.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(booleanListNamedStyleEClass, BooleanListNamedStyle.class, "BooleanListNamedStyle", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getBooleanListNamedStyle_Values(), ecorePackage.getEBoolean(), "values", null, 0, -1, BooleanListNamedStyle.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(doubleListNamedStyleEClass, DoubleListNamedStyle.class, "DoubleListNamedStyle", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getDoubleListNamedStyle_Values(), ecorePackage.getEDouble(), "values", null, 0, -1, DoubleListNamedStyle.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(styledElementEClass, StyledElement.class, "StyledElement", IS_ABSTRACT, IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getStyledElement_NamedStyles(), this.getNamedStyle(), null, "namedStyles", null, 0, -1, StyledElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, //$NON-NLS-1$
+				!IS_ORDERED);
+
+		EOperation op = initEOperation(getStyledElement__GetNamedStyle__String(), this.getNamedStyle(), "getNamedStyle", 1, 1, IS_UNIQUE, !IS_ORDERED); //$NON-NLS-1$
+		addEParameter(op, ecorePackage.getEString(), "name", 1, 1, IS_UNIQUE, !IS_ORDERED); //$NON-NLS-1$
+
+		// Create resource
+		createResource(eNS_URI);
+
+		// Create annotations
+		// http://www.eclipse.org/uml2/2.0.0/UML
+		createUMLAnnotations();
+	}
+
+	/**
+	 * Initializes the annotations for <b>http://www.eclipse.org/uml2/2.0.0/UML</b>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected void createUMLAnnotations() {
+		String source = "http://www.eclipse.org/uml2/2.0.0/UML"; //$NON-NLS-1$
+		addAnnotation(this,
+				source,
+				new String[] {
+						"originalName", "Styles" //$NON-NLS-1$ //$NON-NLS-2$
+				});
+	}
+
+} // StylesPackageImpl
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/util/StylesAdapterFactory.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/util/StylesAdapterFactory.java
new file mode 100755
index 0000000..3a87533
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/util/StylesAdapterFactory.java
@@ -0,0 +1,320 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.papyrus.model2doc.core.styles.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage
+ * @generated
+ */
+public class StylesAdapterFactory extends AdapterFactoryImpl {
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected static StylesPackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public StylesAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = StylesPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject) object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected StylesSwitch<Adapter> modelSwitch = new StylesSwitch<>() {
+		@Override
+		public Adapter caseNamedStyle(NamedStyle object) {
+			return createNamedStyleAdapter();
+		}
+
+		@Override
+		public Adapter caseIntNamedStyle(IntNamedStyle object) {
+			return createIntNamedStyleAdapter();
+		}
+
+		@Override
+		public Adapter caseStringNamedStyle(StringNamedStyle object) {
+			return createStringNamedStyleAdapter();
+		}
+
+		@Override
+		public Adapter caseBooleanNamedStyle(BooleanNamedStyle object) {
+			return createBooleanNamedStyleAdapter();
+		}
+
+		@Override
+		public Adapter caseDoubleNamedStyle(DoubleNamedStyle object) {
+			return createDoubleNamedStyleAdapter();
+		}
+
+		@Override
+		public Adapter caseIntListNamedStyle(IntListNamedStyle object) {
+			return createIntListNamedStyleAdapter();
+		}
+
+		@Override
+		public Adapter caseStringListNamedStyle(StringListNamedStyle object) {
+			return createStringListNamedStyleAdapter();
+		}
+
+		@Override
+		public Adapter caseBooleanListNamedStyle(BooleanListNamedStyle object) {
+			return createBooleanListNamedStyleAdapter();
+		}
+
+		@Override
+		public Adapter caseDoubleListNamedStyle(DoubleListNamedStyle object) {
+			return createDoubleListNamedStyleAdapter();
+		}
+
+		@Override
+		public Adapter caseStyledElement(StyledElement object) {
+			return createStyledElementAdapter();
+		}
+
+		@Override
+		public Adapter defaultCase(EObject object) {
+			return createEObjectAdapter();
+		}
+	};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @param target
+	 *            the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject) target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.NamedStyle <em>Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.NamedStyle
+	 * @generated
+	 */
+	public Adapter createNamedStyleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle <em>Int Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.IntNamedStyle
+	 * @generated
+	 */
+	public Adapter createIntNamedStyleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle <em>String Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StringNamedStyle
+	 * @generated
+	 */
+	public Adapter createStringNamedStyleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle <em>Boolean Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.BooleanNamedStyle
+	 * @generated
+	 */
+	public Adapter createBooleanNamedStyleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle <em>Double Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.DoubleNamedStyle
+	 * @generated
+	 */
+	public Adapter createDoubleNamedStyleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle <em>Int List Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.IntListNamedStyle
+	 * @generated
+	 */
+	public Adapter createIntListNamedStyleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle <em>String List Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StringListNamedStyle
+	 * @generated
+	 */
+	public Adapter createStringListNamedStyleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle <em>Boolean List Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.BooleanListNamedStyle
+	 * @generated
+	 */
+	public Adapter createBooleanListNamedStyleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle <em>Double List Named Style</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.DoubleListNamedStyle
+	 * @generated
+	 */
+	public Adapter createDoubleListNamedStyleAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.StyledElement <em>Styled Element</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StyledElement
+	 * @generated
+	 */
+	public Adapter createStyledElementAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+} // StylesAdapterFactory
diff --git a/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/util/StylesSwitch.java b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/util/StylesSwitch.java
new file mode 100755
index 0000000..d8af7ce
--- /dev/null
+++ b/plugins/core/org.eclipse.papyrus.model2doc.core.styles/src-gen/org/eclipse/papyrus/model2doc/core/styles/util/StylesSwitch.java
@@ -0,0 +1,383 @@
+/**
+ * Copyright (c) 2020 CEA LIST.
+ *
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ *
+ *  SPDX-License-Identifier: EPL-2.0
+ *
+ *  Contributors:
+ *  Pauline DEVILLE (CEA LIST) pauline.deville@cea.fr - Initial API and implementation
+ */
+package org.eclipse.papyrus.model2doc.core.styles.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+import org.eclipse.papyrus.model2doc.core.styles.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Switch</b> for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ * <!-- end-user-doc -->
+ *
+ * @see org.eclipse.papyrus.model2doc.core.styles.StylesPackage
+ * @generated
+ */
+public class StylesSwitch<T> extends Switch<T> {
+	/**
+	 * The cached model package
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	protected static StylesPackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 */
+	public StylesSwitch() {
+		if (modelPackage == null) {
+			modelPackage = StylesPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @param ePackage
+	 *            the package in question.
+	 * @return whether this is a switch for the given package.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @generated
+	 */
+	@Override
+	protected T doSwitch(int classifierID, EObject theEObject) {
+		switch (classifierID) {
+		case StylesPackage.NAMED_STYLE: {
+			NamedStyle namedStyle = (NamedStyle) theEObject;
+			T result = caseNamedStyle(namedStyle);
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		case StylesPackage.INT_NAMED_STYLE: {
+			IntNamedStyle intNamedStyle = (IntNamedStyle) theEObject;
+			T result = caseIntNamedStyle(intNamedStyle);
+			if (result == null) {
+				result = caseNamedStyle(intNamedStyle);
+			}
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		case StylesPackage.STRING_NAMED_STYLE: {
+			StringNamedStyle stringNamedStyle = (StringNamedStyle) theEObject;
+			T result = caseStringNamedStyle(stringNamedStyle);
+			if (result == null) {
+				result = caseNamedStyle(stringNamedStyle);
+			}
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		case StylesPackage.BOOLEAN_NAMED_STYLE: {
+			BooleanNamedStyle booleanNamedStyle = (BooleanNamedStyle) theEObject;
+			T result = caseBooleanNamedStyle(booleanNamedStyle);
+			if (result == null) {
+				result = caseNamedStyle(booleanNamedStyle);
+			}
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		case StylesPackage.DOUBLE_NAMED_STYLE: {
+			DoubleNamedStyle doubleNamedStyle = (DoubleNamedStyle) theEObject;
+			T result = caseDoubleNamedStyle(doubleNamedStyle);
+			if (result == null) {
+				result = caseNamedStyle(doubleNamedStyle);
+			}
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		case StylesPackage.INT_LIST_NAMED_STYLE: {
+			IntListNamedStyle intListNamedStyle = (IntListNamedStyle) theEObject;
+			T result = caseIntListNamedStyle(intListNamedStyle);
+			if (result == null) {
+				result = caseNamedStyle(intListNamedStyle);
+			}
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		case StylesPackage.STRING_LIST_NAMED_STYLE: {
+			StringListNamedStyle stringListNamedStyle = (StringListNamedStyle) theEObject;
+			T result = caseStringListNamedStyle(stringListNamedStyle);
+			if (result == null) {
+				result = caseNamedStyle(stringListNamedStyle);
+			}
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		case StylesPackage.BOOLEAN_LIST_NAMED_STYLE: {
+			BooleanListNamedStyle booleanListNamedStyle = (BooleanListNamedStyle) theEObject;
+			T result = caseBooleanListNamedStyle(booleanListNamedStyle);
+			if (result == null) {
+				result = caseNamedStyle(booleanListNamedStyle);
+			}
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		case StylesPackage.DOUBLE_LIST_NAMED_STYLE: {
+			DoubleListNamedStyle doubleListNamedStyle = (DoubleListNamedStyle) theEObject;
+			T result = caseDoubleListNamedStyle(doubleListNamedStyle);
+			if (result == null) {
+				result = caseNamedStyle(doubleListNamedStyle);
+			}
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		case StylesPackage.STYLED_ELEMENT: {
+			StyledElement styledElement = (StyledElement) theEObject;
+			T result = caseStyledElement(styledElement);
+			if (result == null) {
+				result = defaultCase(theEObject);
+			}
+			return result;
+		}
+		default:
+			return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Named Style</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseNamedStyle(NamedStyle object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Int Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Int Named Style</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseIntNamedStyle(IntNamedStyle object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>String Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>String Named Style</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseStringNamedStyle(StringNamedStyle object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Boolean Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Boolean Named Style</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseBooleanNamedStyle(BooleanNamedStyle object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Double Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Double Named Style</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseDoubleNamedStyle(DoubleNamedStyle object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Int List Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Int List Named Style</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseIntListNamedStyle(IntListNamedStyle object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>String List Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>String List Named Style</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseStringListNamedStyle(StringListNamedStyle object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Boolean List Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Boolean List Named Style</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseBooleanListNamedStyle(BooleanListNamedStyle object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Double List Named Style</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Double List Named Style</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseDoubleListNamedStyle(DoubleListNamedStyle object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Styled Element</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Styled Element</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseStyledElement(StyledElement object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+} // StylesSwitch
diff --git a/plugins/core/pom.xml b/plugins/core/pom.xml
index 284cbc4..51310e2 100755
--- a/plugins/core/pom.xml
+++ b/plugins/core/pom.xml
@@ -27,6 +27,8 @@
 		<module>org.eclipse.papyrus.model2doc.core.generatorconfiguration</module>
 		<module>org.eclipse.papyrus.model2doc.core.generatorconfiguration.edit</module>
 		<module>org.eclipse.papyrus.model2doc.core.onefile</module>
+		<module>org.eclipse.papyrus.model2doc.core.styles</module>
+		<module>org.eclipse.papyrus.model2doc.core.styles.edit</module>
 		<module>org.eclipse.papyrus.model2doc.core.ui</module>
 	</modules>
 </project>
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/.classpath b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/.classpath
index d7873d7..8992fd5 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/.classpath
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/.classpath
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="src" path="src-gen"/>
 	<classpathentry kind="src" path="api"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/META-INF/MANIFEST.MF b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/META-INF/MANIFEST.MF
index a1063db..08dca6f 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/META-INF/MANIFEST.MF
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/META-INF/MANIFEST.MF
@@ -19,10 +19,13 @@
  org.eclipse.emf.ecore.edit;bundle-version="[2.12.0,3.0.0)",
  org.eclipse.papyrus.model2doc.core.generatorconfiguration;bundle-version="[0.7.0,1.0.0)",
  org.eclipse.papyrus.model2doc.core.generatorconfiguration.edit;bundle-version="[0.7.0,1.0.0)",
+ org.eclipse.papyrus.model2doc.core.styles;bundle-version="[0.8.0,1.0.0)",
+ org.eclipse.papyrus.model2doc.core.styles.edit;bundle-version="[0.8.0,1.0.0)",
  org.eclipse.papyrus.model2doc.core.builtintypes;bundle-version="[0.7.0,1.0.0)",
  org.eclipse.papyrus.model2doc.core.builtintypes.edit;bundle-version="[0.7.0,1.0.0)",
  org.eclipse.papyrus.model2doc.core.author;bundle-version="[0.7.0,1.0.0)",
  org.eclipse.papyrus.model2doc.core.author.edit;bundle-version="[0.7.0,1.0.0)",
  org.eclipse.emf.common.ui;bundle-version="[2.15.0,3.0.0)",
  org.eclipse.emf.edit.ui;bundle-version="[2.16.0,3.0.0)"
+Import-Package: org.osgi.framework
 Bundle-ActivationPolicy: lazy
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/provider/DocumentstructureEditPlugin.java b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/provider/DocumentstructureEditPlugin.java
index 82d94f7..f53c411 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/provider/DocumentstructureEditPlugin.java
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure.edit/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/provider/DocumentstructureEditPlugin.java
@@ -24,20 +24,19 @@
 
 import org.eclipse.papyrus.model2doc.core.generatorconfiguration.provider.GeneratorconfigurationEditPlugin;
 
+import org.eclipse.papyrus.model2doc.core.styles.provider.StylesEditPlugin;
 import org.osgi.framework.BundleActivator;
 
 /**
- * This is the central singleton for the Documentstructure edit plugin.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
+ * This is the central singleton for the Documentstructure edit plugin. <!--
+ * begin-user-doc --> <!-- end-user-doc -->
  *
  * @generated
  */
 public final class DocumentstructureEditPlugin extends EMFPlugin {
 	/**
 	 * Keep track of the singleton.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
 	 *
 	 * @generated
 	 */
@@ -45,8 +44,7 @@
 
 	/**
 	 * Keep track of the singleton.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
 	 *
 	 * @generated
 	 */
@@ -54,8 +52,7 @@
 
 	/**
 	 * Create the instance.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
 	 *
 	 * @generated
 	 */
@@ -65,6 +62,7 @@
 				BuiltInTypesEditPlugin.INSTANCE,
 				EcoreEditPlugin.INSTANCE,
 				GeneratorconfigurationEditPlugin.INSTANCE,
+				StylesEditPlugin.INSTANCE,
 		});
 	}
 
@@ -95,16 +93,15 @@
 
 	/**
 	 * The actual implementation of the Eclipse <b>Plugin</b>.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
 	 *
 	 * @generated
 	 */
 	public static class Implementation extends EclipsePlugin {
 		/**
 		 * Creates an instance.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->
 		 *
 		 * @generated
 		 */
@@ -118,8 +115,7 @@
 
 		/**
 		 * The actual implementation of the purely OSGi-compatible <b>Bundle Activator</b>.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * <!-- begin-user-doc --> <!-- end-user-doc -->
 		 *
 		 * @generated
 		 */
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/META-INF/MANIFEST.MF b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/META-INF/MANIFEST.MF
index b9c9c7b..f1734fe 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/META-INF/MANIFEST.MF
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/META-INF/MANIFEST.MF
@@ -15,6 +15,7 @@
 Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.15.0,4.0.0)";resolution:=optional;x-installation:=greedy,
  org.eclipse.emf.ecore;bundle-version="[2.17.0,3.0.0)",
  org.eclipse.papyrus.model2doc.core.generatorconfiguration;bundle-version="[0.7.0,1.0.0)",
+ org.eclipse.papyrus.model2doc.core.styles;bundle-version="[0.8.0,1.0.0)",
  org.eclipse.emf.ecore.xmi;bundle-version="[2.15.0,3.0.0)",
  org.eclipse.papyrus.emf;bundle-version="[2.0.0,3.0.0)",
  org.eclipse.papyrus.model2doc.core.builtintypes;bundle-version="[0.7.0,1.0.0)",
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/model/documentstructure.genmodel b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/model/documentstructure.genmodel
index d4ec0db..4e1b7d4 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/model/documentstructure.genmodel
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/model/documentstructure.genmodel
@@ -12,7 +12,7 @@
     codeFormatting="true" commentFormatting="true" testsDirectory="/org.eclipse.papyrus.model2doc.emf.documentstructure.tests/src-gen"
     testSuiteClass="org.eclipse.papyrus.model2doc.emf.documentstructure.tests.DocumentstructureAllTests"
     importerID="org.eclipse.uml2.uml.ecore.importer" complianceLevel="8.0" copyrightFields="false"
-    usedGenPackages="../../org.eclipse.papyrus.model2doc.core.author/model/author.genmodel#//author ../../org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.genmodel#//builtintypes ../../org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore ../../org.eclipse.papyrus.model2doc.core.generatorconfiguration/model/generatorconfiguration.genmodel#//generatorconfiguration"
+    usedGenPackages="../../org.eclipse.papyrus.model2doc.core.author/model/author.genmodel#//author ../../org.eclipse.papyrus.model2doc.core.builtintypes/model/BuiltInTypes.genmodel#//builtintypes ../../org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore ../../org.eclipse.papyrus.model2doc.core.generatorconfiguration/model/generatorconfiguration.genmodel#//generatorconfiguration ../../org.eclipse.papyrus.model2doc.core.styles/model/Styles.genmodel#//styles"
     operationReflection="true" importOrganizing="true" cleanup="true" oSGiCompatible="true"
     pluralizedGetters="true">
   <genAnnotations source="http://www.eclipse.org/emf/2002/GenModel/importer/org.eclipse.uml2.uml.ecore.importer">
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/Document.java b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/Document.java
index 6f15bf7..6005347 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/Document.java
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/Document.java
@@ -14,9 +14,11 @@
 package org.eclipse.papyrus.model2doc.emf.documentstructure;
 
 import org.eclipse.emf.common.util.EList;
+
 import org.eclipse.emf.ecore.EObject;
 
 import org.eclipse.papyrus.model2doc.core.author.IAuthor;
+
 import org.eclipse.papyrus.model2doc.core.generatorconfiguration.IDocumentGeneratorConfiguration;
 
 /**
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/DocumentStructurePackage.java b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/DocumentStructurePackage.java
index daa0a39..e64ccf9 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/DocumentStructurePackage.java
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/DocumentStructurePackage.java
@@ -924,6 +924,16 @@
 	int EXTENDED_TEXT_CELL = 16;
 
 	/**
+	 * The feature id for the '<em><b>Named Styles</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int EXTENDED_TEXT_CELL__NAMED_STYLES = BuiltInTypesPackage.TEXT_CELL__NAMED_STYLES;
+
+	/**
 	 * The feature id for the '<em><b>Location</b></em>' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -964,6 +974,16 @@
 	int EXTENDED_TEXT_CELL_FEATURE_COUNT = BuiltInTypesPackage.TEXT_CELL_FEATURE_COUNT + 1;
 
 	/**
+	 * The operation id for the '<em>Get Named Style</em>' operation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 *
+	 * @generated
+	 * @ordered
+	 */
+	int EXTENDED_TEXT_CELL___GET_NAMED_STYLE__STRING = BuiltInTypesPackage.TEXT_CELL___GET_NAMED_STYLE__STRING;
+
+	/**
 	 * The number of operations of the '<em>Extended Text Cell</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1095,7 +1115,6 @@
 	 */
 	int EXTENDED_TEXT_LIST_ITEM_OPERATION_COUNT = BuiltInTypesPackage.TEXT_LIST_ITEM_OPERATION_COUNT + 0;
 
-
 	/**
 	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.emf.documentstructure.impl.StringVersionImpl <em>String Version</em>}' class.
 	 * <!-- begin-user-doc -->
@@ -1147,7 +1166,6 @@
 	 */
 	int STRING_VERSION_OPERATION_COUNT = VERSION_OPERATION_COUNT + 0;
 
-
 	/**
 	 * The meta object id for the '{@link org.eclipse.papyrus.model2doc.emf.documentstructure.impl.InsertedFileImpl <em>Inserted File</em>}' class.
 	 * <!-- begin-user-doc -->
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/TableOfContents.java b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/TableOfContents.java
index 33d2c9f..41bb676 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/TableOfContents.java
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/TableOfContents.java
@@ -39,10 +39,6 @@
 	 * Returns the value of the '<em><b>Toc Title</b></em>' attribute.
 	 * The default value is <code>"Table Of Contents"</code>.
 	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Toc Title</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
 	 * <!-- end-user-doc -->
 	 * <!-- begin-model-doc -->
 	 * The title to use for the created Table of Contents.
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/impl/DocumentStructurePackageImpl.java b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/impl/DocumentStructurePackageImpl.java
index 6e327dc..b5d4707 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/impl/DocumentStructurePackageImpl.java
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/impl/DocumentStructurePackageImpl.java
@@ -23,10 +23,11 @@
 import org.eclipse.emf.ecore.impl.EPackageImpl;
 
 import org.eclipse.papyrus.model2doc.core.author.AuthorPackage;
-import org.eclipse.papyrus.model2doc.core.builtintypes.BuiltInTypesPackage;
 
+import org.eclipse.papyrus.model2doc.core.builtintypes.BuiltInTypesPackage;
 import org.eclipse.papyrus.model2doc.core.generatorconfiguration.GeneratorConfigurationPackage;
 
+import org.eclipse.papyrus.model2doc.core.styles.StylesPackage;
 import org.eclipse.papyrus.model2doc.emf.documentstructure.Body;
 import org.eclipse.papyrus.model2doc.emf.documentstructure.BodyPart;
 import org.eclipse.papyrus.model2doc.emf.documentstructure.ComposedBodyPart;
@@ -286,6 +287,7 @@
 		BuiltInTypesPackage.eINSTANCE.eClass();
 		EcorePackage.eINSTANCE.eClass();
 		GeneratorConfigurationPackage.eINSTANCE.eClass();
+		StylesPackage.eINSTANCE.eClass();
 
 		// Create package meta-data objects
 		theDocumentStructurePackage.createPackageContents();
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/impl/TextDocumentImpl.java b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/impl/TextDocumentImpl.java
index 5b76397..c248c2f 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/impl/TextDocumentImpl.java
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/impl/TextDocumentImpl.java
@@ -30,6 +30,7 @@
 import org.eclipse.emf.ecore.util.InternalEList;
 
 import org.eclipse.papyrus.model2doc.core.author.IAuthor;
+
 import org.eclipse.papyrus.model2doc.core.generatorconfiguration.IDocumentGeneratorConfiguration;
 
 import org.eclipse.papyrus.model2doc.emf.documentstructure.DocumentStructurePackage;
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/util/DocumentStructureAdapterFactory.java b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/util/DocumentStructureAdapterFactory.java
index dbd298e..9e80b78 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/util/DocumentStructureAdapterFactory.java
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/util/DocumentStructureAdapterFactory.java
@@ -30,7 +30,7 @@
 import org.eclipse.papyrus.model2doc.core.builtintypes.ListItem;
 import org.eclipse.papyrus.model2doc.core.builtintypes.TextCell;
 import org.eclipse.papyrus.model2doc.core.builtintypes.TextListItem;
-
+import org.eclipse.papyrus.model2doc.core.styles.StyledElement;
 import org.eclipse.papyrus.model2doc.emf.documentstructure.*;
 
 /**
@@ -92,7 +92,7 @@
 	 *
 	 * @generated
 	 */
-	protected DocumentStructureSwitch<Adapter> modelSwitch = new DocumentStructureSwitch<Adapter>() {
+	protected DocumentStructureSwitch<Adapter> modelSwitch = new DocumentStructureSwitch<>() {
 		@Override
 		public Adapter caseTextDocument(TextDocument object) {
 			return createTextDocumentAdapter();
@@ -209,6 +209,11 @@
 		}
 
 		@Override
+		public Adapter caseStyledElement(StyledElement object) {
+			return createStyledElementAdapter();
+		}
+
+		@Override
 		public Adapter caseCell(Cell object) {
 			return createCellAdapter();
 		}
@@ -616,6 +621,21 @@
 	}
 
 	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.styles.StyledElement <em>Styled Element</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 *
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.model2doc.core.styles.StyledElement
+	 * @generated
+	 */
+	public Adapter createStyledElementAdapter() {
+		return null;
+	}
+
+	/**
 	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.model2doc.core.builtintypes.Cell <em>Cell</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
diff --git a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/util/DocumentStructureSwitch.java b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/util/DocumentStructureSwitch.java
index 1e53269..9f7c430 100755
--- a/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/util/DocumentStructureSwitch.java
+++ b/plugins/emf/org.eclipse.papyrus.model2doc.emf.documentstructure/src-gen/org/eclipse/papyrus/model2doc/emf/documentstructure/util/DocumentStructureSwitch.java
@@ -28,7 +28,7 @@
 import org.eclipse.papyrus.model2doc.core.builtintypes.ListItem;
 import org.eclipse.papyrus.model2doc.core.builtintypes.TextCell;
 import org.eclipse.papyrus.model2doc.core.builtintypes.TextListItem;
-
+import org.eclipse.papyrus.model2doc.core.styles.StyledElement;
 import org.eclipse.papyrus.model2doc.emf.documentstructure.*;
 
 /**
@@ -283,6 +283,9 @@
 				result = caseCell(extendedTextCell);
 			}
 			if (result == null) {
+				result = caseStyledElement(extendedTextCell);
+			}
+			if (result == null) {
 				result = defaultCase(theEObject);
 			}
 			return result;
@@ -749,6 +752,23 @@
 	}
 
 	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Styled Element</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 *
+	 * @param object
+	 *                   the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Styled Element</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseStyledElement(StyledElement object) {
+		return null;
+	}
+
+	/**
 	 * Returns the result of interpreting the object as an instance of '<em>Cell</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
diff --git a/plugins/odt/org.eclipse.papyrus.model2doc.odt/META-INF/MANIFEST.MF b/plugins/odt/org.eclipse.papyrus.model2doc.odt/META-INF/MANIFEST.MF
index 0961758..3dea9bb 100755
--- a/plugins/odt/org.eclipse.papyrus.model2doc.odt/META-INF/MANIFEST.MF
+++ b/plugins/odt/org.eclipse.papyrus.model2doc.odt/META-INF/MANIFEST.MF
@@ -26,7 +26,8 @@
  org.eclipse.papyrus.model2doc.core.builtintypes;bundle-version="[0.7.0,1.0.0)",
  org.eclipse.papyrus.model2doc.core.author;bundle-version="[0.7.0,1.0.0)",
  org.eclipse.papyrus.infra.core.sasheditor;bundle-version="[3.0.0,4.0.0)",
- org.eclipse.papyrus.infra.core.sashwindows.di;bundle-version="[2.0.0,3.0.0)"
+ org.eclipse.papyrus.infra.core.sashwindows.di;bundle-version="[2.0.0,3.0.0)",
+ org.eclipse.papyrus.model2doc.core.styles;bundle-version="[0.8.0,1.0.0)"
 Bundle-RequiredExecutionEnvironment: JavaSE-11
 Bundle-ActivationPolicy: lazy
 Export-Package: org.eclipse.papyrus.model2doc.odt.editor,
